sig
  module Std :
    sig
      module Monoid :
        sig
          module type Base =
            sig
              type t
              val zero : Monads.Std.Monoid.Base.t
              val plus :
                Monads.Std.Monoid.Base.t ->
                Monads.Std.Monoid.Base.t -> Monads.Std.Monoid.Base.t
            end
          module type S =
            sig
              type t
              val zero : t
              val plus : t -> t -> t
              val concat : t list -> t
              val ( @@ ) : t -> t -> t
            end
          module Make :
            functor (M : Base->
              sig
                val zero : M.t
                val plus : M.t -> M.t -> M.t
                val concat : M.t list -> M.t
                val ( @@ ) : M.t -> M.t -> M.t
              end
          module Unit :
            sig
              type t = unit
              val zero : t
              val plus : t -> t -> t
              val concat : t list -> t
              val ( @@ ) : t -> t -> t
            end
          module TList :
            functor (T : Core_kernel.Std.T-> sig type t = T.t list end
          module Stack :
            sig
              module Make :
                functor (T : Core_kernel.Std.T->
                  sig
                    val zero : TList(T).t
                    val plus : TList(T).t -> TList(T).t -> TList(T).t
                    val concat : TList(T).t list -> TList(T).t
                    val ( @@ ) : TList(T).t -> TList(T).t -> TList(T).t
                  end
            end
          module List :
            sig
              module Make :
                functor (T : Core_kernel.Std.T->
                  sig
                    val zero : TList(T).t
                    val plus : TList(T).t -> TList(T).t -> TList(T).t
                    val concat : TList(T).t list -> TList(T).t
                    val ( @@ ) : TList(T).t -> TList(T).t -> TList(T).t
                  end
            end
          module String :
            sig
              type t = string
              val zero : t
              val plus : t -> t -> t
              val concat : t list -> t
              val ( @@ ) : t -> t -> t
            end
          module Set :
            sig
              module Make :
                functor (S : Core_kernel.Std.Set.S->
                  sig
                    val zero : S.t
                    val plus : S.t -> S.t -> S.t
                    val concat : S.t list -> S.t
                    val ( @@ ) : S.t -> S.t -> S.t
                  end
            end
          module Int :
            sig
              type t = int
              val zero : t
              val plus : t -> t -> t
              val concat : t list -> t
              val ( @@ ) : t -> t -> t
              module Sum :
                sig
                  type t = int
                  val zero : t
                  val plus : t -> t -> t
                  val concat : t list -> t
                  val ( @@ ) : t -> t -> t
                end
              module Product :
                sig
                  type t = Sum.t
                  val zero : t
                  val plus : t -> t -> t
                  val concat : t list -> t
                  val ( @@ ) : t -> t -> t
                end
            end
          module Float :
            sig
              type t = float
              val zero : t
              val plus : t -> t -> t
              val concat : t list -> t
              val ( @@ ) : t -> t -> t
              module Sum :
                sig
                  type t = float
                  val zero : t
                  val plus : t -> t -> t
                  val concat : t list -> t
                  val ( @@ ) : t -> t -> t
                end
              module Product :
                sig
                  type t = Sum.t
                  val zero : t
                  val plus : t -> t -> t
                  val concat : t list -> t
                  val ( @@ ) : t -> t -> t
                end
            end
        end
      module Monad :
        sig
          module Plus :
            sig
              module type S =
                sig
                  type 'a t
                  val zero : unit -> 'Monads.Std.Monad.Plus.S.t
                  val plus :
                    'Monads.Std.Monad.Plus.S.t ->
                    'Monads.Std.Monad.Plus.S.t ->
                    'Monads.Std.Monad.Plus.S.t
                end
              module type S2 =
                sig
                  type ('a, 'e) t
                  val zero : unit -> ('a, 'e) Monads.Std.Monad.Plus.S2.t
                  val plus :
                    ('a, 'e) Monads.Std.Monad.Plus.S2.t ->
                    ('a, 'e) Monads.Std.Monad.Plus.S2.t ->
                    ('a, 'e) Monads.Std.Monad.Plus.S2.t
                end
            end
          module Fail :
            sig
              module type S =
                sig
                  type 'a error
                  type 'a t
                  val fail :
                    'Monads.Std.Monad.Fail.S.error ->
                    'Monads.Std.Monad.Fail.S.t
                  val catch :
                    'Monads.Std.Monad.Fail.S.t ->
                    ('Monads.Std.Monad.Fail.S.error ->
                     'Monads.Std.Monad.Fail.S.t) ->
                    'Monads.Std.Monad.Fail.S.t
                end
              module type S2 =
                sig
                  type 'a error
                  type ('a, 'e) t
                  val fail :
                    'Monads.Std.Monad.Fail.S2.error ->
                    ('a, 'e) Monads.Std.Monad.Fail.S2.t
                  val catch :
                    ('a, 'e) Monads.Std.Monad.Fail.S2.t ->
                    ('Monads.Std.Monad.Fail.S2.error ->
                     ('a, 'e) Monads.Std.Monad.Fail.S2.t) ->
                    ('a, 'e) Monads.Std.Monad.Fail.S2.t
                end
            end
          module Choice :
            sig
              module type Basic =
                sig
                  type 'a t
                  val pure : '-> 'Monads.Std.Monad.Choice.Basic.t
                  val zero : unit -> 'Monads.Std.Monad.Choice.Basic.t
                end
              module type S =
                sig
                  type 'a t
                  val pure : '-> 'a t
                  val zero : Monoid.Unit.t -> 'a t
                  val accept : '-> 'Monads.Std.Monad.Choice.S.t
                  val reject : unit -> 'Monads.Std.Monad.Choice.S.t
                  val guard : bool -> unit Monads.Std.Monad.Choice.S.t
                  val on :
                    bool ->
                    unit Monads.Std.Monad.Choice.S.t ->
                    unit Monads.Std.Monad.Choice.S.t
                  val unless :
                    bool ->
                    unit Monads.Std.Monad.Choice.S.t ->
                    unit Monads.Std.Monad.Choice.S.t
                end
              module type Basic2 =
                sig
                  type ('a, 'e) t
                  val pure : '-> ('a, 'e) Monads.Std.Monad.Choice.Basic2.t
                  val zero :
                    unit -> ('a, 'e) Monads.Std.Monad.Choice.Basic2.t
                end
              module type S2 =
                sig
                  type ('a, 'e) t
                  val pure : '-> ('a, 'e) t
                  val zero : Monoid.Unit.t -> ('a, 'e) t
                  val accept : '-> ('a, 'e) Monads.Std.Monad.Choice.S2.t
                  val reject : unit -> ('a, 'e) Monads.Std.Monad.Choice.S2.t
                  val guard : bool -> (unit, 'e) Monads.Std.Monad.Choice.S2.t
                  val on :
                    bool ->
                    (unit, 'e) Monads.Std.Monad.Choice.S2.t ->
                    (unit, 'e) Monads.Std.Monad.Choice.S2.t
                  val unless :
                    bool ->
                    (unit, 'e) Monads.Std.Monad.Choice.S2.t ->
                    (unit, 'e) Monads.Std.Monad.Choice.S2.t
                end
              module Make :
                functor (M : Basic->
                  sig
                    val pure : '-> 'M.t
                    val zero : Monoid.Unit.t -> 'M.t
                    val accept : '-> 'M.t
                    val reject : Monoid.Unit.t -> 'M.t
                    val guard : bool -> Monoid.Unit.t M.t
                    val on : bool -> Monoid.Unit.t M.t -> Monoid.Unit.t M.t
                    val unless :
                      bool -> Monoid.Unit.t M.t -> Monoid.Unit.t M.t
                  end
              module Make2 :
                functor (M : Basic2->
                  sig
                    val pure : '-> ('a, 'e) M.t
                    val zero : Monoid.Unit.t -> ('a, 'e) M.t
                    val accept : '-> ('a, 'e) M.t
                    val reject : Monoid.Unit.t -> ('a, 'e) M.t
                    val guard : bool -> (Monoid.Unit.t, 'e) M.t
                    val on :
                      bool ->
                      (Monoid.Unit.t, 'e) M.t -> (Monoid.Unit.t, 'e) M.t
                    val unless :
                      bool ->
                      (Monoid.Unit.t, 'e) M.t -> (Monoid.Unit.t, 'e) M.t
                  end
            end
          module Trans :
            sig
              module type S =
                sig
                  type 'a t
                  type 'a m
                  type 'a e
                  val lift :
                    'Monads.Std.Monad.Trans.S.m ->
                    'Monads.Std.Monad.Trans.S.t
                  val run :
                    'Monads.Std.Monad.Trans.S.t ->
                    'Monads.Std.Monad.Trans.S.e
                end
              module type S1 =
                sig
                  type ('a, 'e) t
                  type 'a m
                  type ('a, 'e) e
                  val lift :
                    'Monads.Std.Monad.Trans.S1.m ->
                    ('a, 'e) Monads.Std.Monad.Trans.S1.t
                  val run :
                    ('a, 'e) Monads.Std.Monad.Trans.S1.t ->
                    ('a, 'e) Monads.Std.Monad.Trans.S1.e
                end
              module type S2 =
                sig
                  type ('a, 'e) t
                  type ('a, 'e) m
                  type ('a, 'e) e
                  val lift :
                    ('a, 'e) Monads.Std.Monad.Trans.S2.m ->
                    ('a, 'e) Monads.Std.Monad.Trans.S2.t
                  val run :
                    ('a, 'e) Monads.Std.Monad.Trans.S2.t ->
                    ('a, 'e) Monads.Std.Monad.Trans.S2.e
                end
            end
          module type Basic =
            sig
              type 'a t
              val bind :
                'Monads.Std.Monad.Basic.t ->
                ('-> 'Monads.Std.Monad.Basic.t) ->
                'Monads.Std.Monad.Basic.t
              val return : '-> 'Monads.Std.Monad.Basic.t
              val map :
                [ `Custom of
                    'Monads.Std.Monad.Basic.t ->
                    f:('-> 'b) -> 'Monads.Std.Monad.Basic.t
                | `Define_using_bind ]
            end
          module type Basic2 =
            sig
              type ('a, 'e) t
              val bind :
                ('a, 'e) Monads.Std.Monad.Basic2.t ->
                ('-> ('b, 'e) Monads.Std.Monad.Basic2.t) ->
                ('b, 'e) Monads.Std.Monad.Basic2.t
              val map :
                [ `Custom of
                    ('a, 'e) Monads.Std.Monad.Basic2.t ->
                    f:('-> 'b) -> ('b, 'e) Monads.Std.Monad.Basic2.t
                | `Define_using_bind ]
              val return : '-> ('a, 'b) Monads.Std.Monad.Basic2.t
            end
          module Collection :
            sig
              module type Basic =
                sig
                  type 'a t
                  val return : '-> 'Monads.Std.Monad.Collection.Basic.t
                  val zero : Monoid.Unit.t -> 'a t
                  val plus : 'a t -> 'a t -> 'a t
                end
              module type Eager =
                sig
                  type 'a t
                  val return : '-> 'a t
                  val zero : Monoid.Unit.t -> 'a t
                  val plus : 'a t -> 'a t -> 'a t
                  val fold : 'a t -> init:'-> f:('-> '-> 's) -> 's
                end
              module type Delay =
                sig
                  type 'a t
                  val return : '-> 'a t
                  val zero : Monoid.Unit.t -> 'a t
                  val plus : 'a t -> 'a t -> 'a t
                  val fold :
                    'a t ->
                    init:'->
                    f:('-> '-> ('-> 'r) -> 'r) -> ('-> 'r) -> 'r
                end
              module type S2 =
                sig
                  type ('a, 'e) m
                  type 'a t
                  val all :
                    ('a, 'e) Monads.Std.Monad.Collection.S2.m
                    Monads.Std.Monad.Collection.S2.t ->
                    ('Monads.Std.Monad.Collection.S2.t, 'e)
                    Monads.Std.Monad.Collection.S2.m
                  val all_ignore :
                    ('a, 'e) Monads.Std.Monad.Collection.S2.m
                    Monads.Std.Monad.Collection.S2.t ->
                    (unit, 'e) Monads.Std.Monad.Collection.S2.m
                  val sequence :
                    (unit, 'e) Monads.Std.Monad.Collection.S2.m
                    Monads.Std.Monad.Collection.S2.t ->
                    (unit, 'e) Monads.Std.Monad.Collection.S2.m
                  val map :
                    'Monads.Std.Monad.Collection.S2.t ->
                    f:('-> ('b, 'e) Monads.Std.Monad.Collection.S2.m) ->
                    ('Monads.Std.Monad.Collection.S2.t, 'e)
                    Monads.Std.Monad.Collection.S2.m
                  val iter :
                    'Monads.Std.Monad.Collection.S2.t ->
                    f:('-> (unit, 'e) Monads.Std.Monad.Collection.S2.m) ->
                    (unit, 'e) Monads.Std.Monad.Collection.S2.m
                  val fold :
                    'Monads.Std.Monad.Collection.S2.t ->
                    init:'->
                    f:('-> '-> ('b, 'e) Monads.Std.Monad.Collection.S2.m) ->
                    ('b, 'e) Monads.Std.Monad.Collection.S2.m
                  val fold_left :
                    'Monads.Std.Monad.Collection.S2.t ->
                    init:'->
                    f:('-> '-> ('b, 'e) Monads.Std.Monad.Collection.S2.m) ->
                    ('b, 'e) Monads.Std.Monad.Collection.S2.m
                  val fold_right :
                    'Monads.Std.Monad.Collection.S2.t ->
                    f:('-> '-> ('b, 'e) Monads.Std.Monad.Collection.S2.m) ->
                    init:'-> ('b, 'e) Monads.Std.Monad.Collection.S2.m
                  val reduce :
                    'Monads.Std.Monad.Collection.S2.t ->
                    f:('-> '-> ('a, 'e) Monads.Std.Monad.Collection.S2.m) ->
                    ('a option, 'e) Monads.Std.Monad.Collection.S2.m
                  val exists :
                    'Monads.Std.Monad.Collection.S2.t ->
                    f:('-> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->
                    (bool, 'e) Monads.Std.Monad.Collection.S2.m
                  val for_all :
                    'Monads.Std.Monad.Collection.S2.t ->
                    f:('-> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->
                    (bool, 'e) Monads.Std.Monad.Collection.S2.m
                  val count :
                    'Monads.Std.Monad.Collection.S2.t ->
                    f:('-> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->
                    (int, 'e) Monads.Std.Monad.Collection.S2.m
                  val map_reduce :
                    (module Monads.Std.Monoid.S with type t = 'a) ->
                    'Monads.Std.Monad.Collection.S2.t ->
                    f:('-> ('a, 'e) Monads.Std.Monad.Collection.S2.m) ->
                    ('a, 'e) Monads.Std.Monad.Collection.S2.m
                  val find :
                    'Monads.Std.Monad.Collection.S2.t ->
                    f:('-> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->
                    ('a option, 'e) Monads.Std.Monad.Collection.S2.m
                  val find_map :
                    'Monads.Std.Monad.Collection.S2.t ->
                    f:('-> ('b option, 'e) Monads.Std.Monad.Collection.S2.m) ->
                    ('b option, 'e) Monads.Std.Monad.Collection.S2.m
                  val filter :
                    'Monads.Std.Monad.Collection.S2.t ->
                    f:('-> (bool, 'e) Monads.Std.Monad.Collection.S2.m) ->
                    ('Monads.Std.Monad.Collection.S2.t, 'e)
                    Monads.Std.Monad.Collection.S2.m
                  val filter_map :
                    'Monads.Std.Monad.Collection.S2.t ->
                    f:('-> ('b option, 'e) Monads.Std.Monad.Collection.S2.m) ->
                    ('Monads.Std.Monad.Collection.S2.t, 'e)
                    Monads.Std.Monad.Collection.S2.m
                end
              module type S =
                sig
                  type 'a m
                  type 'a t
                  val all :
                    'Monads.Std.Monad.Collection.S.m
                    Monads.Std.Monad.Collection.S.t ->
                    'Monads.Std.Monad.Collection.S.t
                    Monads.Std.Monad.Collection.S.m
                  val all_ignore :
                    'Monads.Std.Monad.Collection.S.m
                    Monads.Std.Monad.Collection.S.t ->
                    unit Monads.Std.Monad.Collection.S.m
                  val sequence :
                    unit Monads.Std.Monad.Collection.S.m
                    Monads.Std.Monad.Collection.S.t ->
                    unit Monads.Std.Monad.Collection.S.m
                  val map :
                    'Monads.Std.Monad.Collection.S.t ->
                    f:('-> 'Monads.Std.Monad.Collection.S.m) ->
                    'Monads.Std.Monad.Collection.S.t
                    Monads.Std.Monad.Collection.S.m
                  val iter :
                    'Monads.Std.Monad.Collection.S.t ->
                    f:('-> unit Monads.Std.Monad.Collection.S.m) ->
                    unit Monads.Std.Monad.Collection.S.m
                  val fold :
                    'Monads.Std.Monad.Collection.S.t ->
                    init:'->
                    f:('-> '-> 'Monads.Std.Monad.Collection.S.m) ->
                    'Monads.Std.Monad.Collection.S.m
                  val fold_left :
                    'Monads.Std.Monad.Collection.S.t ->
                    init:'->
                    f:('-> '-> 'Monads.Std.Monad.Collection.S.m) ->
                    'Monads.Std.Monad.Collection.S.m
                  val fold_right :
                    'Monads.Std.Monad.Collection.S.t ->
                    f:('-> '-> 'Monads.Std.Monad.Collection.S.m) ->
                    init:'-> 'Monads.Std.Monad.Collection.S.m
                  val reduce :
                    'Monads.Std.Monad.Collection.S.t ->
                    f:('-> '-> 'Monads.Std.Monad.Collection.S.m) ->
                    'a option Monads.Std.Monad.Collection.S.m
                  val exists :
                    'Monads.Std.Monad.Collection.S.t ->
                    f:('-> bool Monads.Std.Monad.Collection.S.m) ->
                    bool Monads.Std.Monad.Collection.S.m
                  val for_all :
                    'Monads.Std.Monad.Collection.S.t ->
                    f:('-> bool Monads.Std.Monad.Collection.S.m) ->
                    bool Monads.Std.Monad.Collection.S.m
                  val count :
                    'Monads.Std.Monad.Collection.S.t ->
                    f:('-> bool Monads.Std.Monad.Collection.S.m) ->
                    int Monads.Std.Monad.Collection.S.m
                  val map_reduce :
                    (module Monads.Std.Monoid.S with type t = 'a) ->
                    'Monads.Std.Monad.Collection.S.t ->
                    f:('-> 'Monads.Std.Monad.Collection.S.m) ->
                    'Monads.Std.Monad.Collection.S.m
                  val find :
                    'Monads.Std.Monad.Collection.S.t ->
                    f:('-> bool Monads.Std.Monad.Collection.S.m) ->
                    'a option Monads.Std.Monad.Collection.S.m
                  val find_map :
                    'Monads.Std.Monad.Collection.S.t ->
                    f:('-> 'b option Monads.Std.Monad.Collection.S.m) ->
                    'b option Monads.Std.Monad.Collection.S.m
                  val filter :
                    'Monads.Std.Monad.Collection.S.t ->
                    f:('-> bool Monads.Std.Monad.Collection.S.m) ->
                    'Monads.Std.Monad.Collection.S.t
                    Monads.Std.Monad.Collection.S.m
                  val filter_map :
                    'Monads.Std.Monad.Collection.S.t ->
                    f:('-> 'b option Monads.Std.Monad.Collection.S.m) ->
                    'Monads.Std.Monad.Collection.S.t
                    Monads.Std.Monad.Collection.S.m
                end
            end
          module Syntax :
            sig
              module type S =
                sig
                  type 'a t
                  val ( >>= ) :
                    'Monads.Std.Monad.Syntax.S.t ->
                    ('-> 'Monads.Std.Monad.Syntax.S.t) ->
                    'Monads.Std.Monad.Syntax.S.t
                  val ( >>| ) :
                    'Monads.Std.Monad.Syntax.S.t ->
                    ('-> 'b) -> 'Monads.Std.Monad.Syntax.S.t
                  val ( >=> ) :
                    ('-> 'Monads.Std.Monad.Syntax.S.t) ->
                    ('-> 'Monads.Std.Monad.Syntax.S.t) ->
                    '-> 'Monads.Std.Monad.Syntax.S.t
                  val ( !! ) : '-> 'Monads.Std.Monad.Syntax.S.t
                  val ( !$ ) :
                    ('-> 'b) ->
                    'Monads.Std.Monad.Syntax.S.t ->
                    'Monads.Std.Monad.Syntax.S.t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    'Monads.Std.Monad.Syntax.S.t ->
                    'Monads.Std.Monad.Syntax.S.t ->
                    'Monads.Std.Monad.Syntax.S.t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    'Monads.Std.Monad.Syntax.S.t ->
                    'Monads.Std.Monad.Syntax.S.t ->
                    'Monads.Std.Monad.Syntax.S.t ->
                    'Monads.Std.Monad.Syntax.S.t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'Monads.Std.Monad.Syntax.S.t ->
                    'Monads.Std.Monad.Syntax.S.t ->
                    'Monads.Std.Monad.Syntax.S.t ->
                    'Monads.Std.Monad.Syntax.S.t ->
                    'Monads.Std.Monad.Syntax.S.t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'Monads.Std.Monad.Syntax.S.t ->
                    'Monads.Std.Monad.Syntax.S.t ->
                    'Monads.Std.Monad.Syntax.S.t ->
                    'Monads.Std.Monad.Syntax.S.t ->
                    'Monads.Std.Monad.Syntax.S.t ->
                    'Monads.Std.Monad.Syntax.S.t
                end
              module type S2 =
                sig
                  type ('a, 'e) t
                  val ( >>= ) :
                    ('a, 'e) Monads.Std.Monad.Syntax.S2.t ->
                    ('-> ('b, 'e) Monads.Std.Monad.Syntax.S2.t) ->
                    ('b, 'e) Monads.Std.Monad.Syntax.S2.t
                  val ( >>| ) :
                    ('a, 'e) Monads.Std.Monad.Syntax.S2.t ->
                    ('-> 'b) -> ('b, 'e) Monads.Std.Monad.Syntax.S2.t
                  val ( >=> ) :
                    ('-> ('b, 'e) Monads.Std.Monad.Syntax.S2.t) ->
                    ('-> ('c, 'e) Monads.Std.Monad.Syntax.S2.t) ->
                    '-> ('c, 'e) Monads.Std.Monad.Syntax.S2.t
                  val ( !! ) : '-> ('a, 'e) Monads.Std.Monad.Syntax.S2.t
                  val ( !$ ) :
                    ('-> 'b) ->
                    ('a, 'e) Monads.Std.Monad.Syntax.S2.t ->
                    ('b, 'e) Monads.Std.Monad.Syntax.S2.t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) Monads.Std.Monad.Syntax.S2.t ->
                    ('b, 'e) Monads.Std.Monad.Syntax.S2.t ->
                    ('c, 'e) Monads.Std.Monad.Syntax.S2.t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) Monads.Std.Monad.Syntax.S2.t ->
                    ('b, 'e) Monads.Std.Monad.Syntax.S2.t ->
                    ('c, 'e) Monads.Std.Monad.Syntax.S2.t ->
                    ('d, 'e) Monads.Std.Monad.Syntax.S2.t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) Monads.Std.Monad.Syntax.S2.t ->
                    ('b, 's) Monads.Std.Monad.Syntax.S2.t ->
                    ('c, 's) Monads.Std.Monad.Syntax.S2.t ->
                    ('d, 's) Monads.Std.Monad.Syntax.S2.t ->
                    ('e, 's) Monads.Std.Monad.Syntax.S2.t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) Monads.Std.Monad.Syntax.S2.t ->
                    ('b, 's) Monads.Std.Monad.Syntax.S2.t ->
                    ('c, 's) Monads.Std.Monad.Syntax.S2.t ->
                    ('d, 's) Monads.Std.Monad.Syntax.S2.t ->
                    ('e, 's) Monads.Std.Monad.Syntax.S2.t ->
                    ('f, 's) Monads.Std.Monad.Syntax.S2.t
                end
            end
          module type S =
            sig
              type 'a t
              val void : 'Monads.Std.Monad.S.t -> unit Monads.Std.Monad.S.t
              val sequence :
                unit Monads.Std.Monad.S.t list -> unit Monads.Std.Monad.S.t
              val forever :
                'Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
              module Fn :
                sig
                  val id : '-> 'Monads.Std.Monad.S.t
                  val ignore :
                    'Monads.Std.Monad.S.t -> unit Monads.Std.Monad.S.t
                  val nothing : unit -> unit Monads.Std.Monad.S.t
                  val non :
                    ('-> bool Monads.Std.Monad.S.t) ->
                    '-> bool Monads.Std.Monad.S.t
                  val apply_n_times :
                    n:int ->
                    ('-> 'Monads.Std.Monad.S.t) ->
                    '-> 'Monads.Std.Monad.S.t
                  val compose :
                    ('-> 'Monads.Std.Monad.S.t) ->
                    ('-> 'Monads.Std.Monad.S.t) ->
                    '-> 'Monads.Std.Monad.S.t
                end
              module Pair :
                sig
                  val fst :
                    ('a * 'b) Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
                  val snd :
                    ('a * 'b) Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
                end
              module Triple :
                sig
                  val fst :
                    ('a * 'b * 'c) Monads.Std.Monad.S.t ->
                    'Monads.Std.Monad.S.t
                  val snd :
                    ('a * 'b * 'c) Monads.Std.Monad.S.t ->
                    'Monads.Std.Monad.S.t
                  val trd :
                    ('a * 'b * 'c) Monads.Std.Monad.S.t ->
                    'Monads.Std.Monad.S.t
                end
              module Lift :
                sig
                  val nullary : '-> 'Monads.Std.Monad.S.t
                  val unary :
                    ('-> 'b) ->
                    'Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
                  val binary :
                    ('-> '-> 'c) ->
                    'Monads.Std.Monad.S.t ->
                    'Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
                  val ternary :
                    ('-> '-> '-> 'd) ->
                    'Monads.Std.Monad.S.t ->
                    'Monads.Std.Monad.S.t ->
                    'Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    'Monads.Std.Monad.S.t ->
                    'Monads.Std.Monad.S.t ->
                    'Monads.Std.Monad.S.t ->
                    'Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'Monads.Std.Monad.S.t ->
                    'Monads.Std.Monad.S.t ->
                    'Monads.Std.Monad.S.t ->
                    'Monads.Std.Monad.S.t ->
                    'Monads.Std.Monad.S.t -> 'Monads.Std.Monad.S.t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(unit -> unit Monads.Std.Monad.S.t) ->
                    f:(unit -> 'Monads.Std.Monad.S.t) ->
                    catch:(exn -> 'Monads.Std.Monad.S.t) ->
                    'Monads.Std.Monad.S.t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : 'a t t -> 'a t t
                      val all_ignore : 'a t t -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                      val map : 'a t -> f:('-> 'b t) -> 'b t t
                      val iter :
                        'a t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'a t -> f:('-> '-> 'a t) -> 'a option t
                      val exists : 'a t -> f:('-> bool t) -> bool t
                      val for_all : 'a t -> f:('-> bool t) -> bool t
                      val count : 'a t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> 'a t) -> 'a t
                      val find : 'a t -> f:('-> bool t) -> 'a option t
                      val find_map :
                        'a t -> f:('-> 'b option t) -> 'b option t
                      val filter : 'a t -> f:('-> bool t) -> 'a t t
                      val filter_map :
                        'a t -> f:('-> 'b option t) -> 'b t t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'a option t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find : 'T.t -> f:('-> bool t) -> 'a option t
                        val find_map :
                          'T.t -> f:('-> 'b option t) -> 'b option t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'b option t) -> 'T.t t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'a option t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find : 'T.t -> f:('-> bool t) -> 'a option t
                        val find_map :
                          'T.t -> f:('-> 'b option t) -> 'b option t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'b option t) -> 'T.t t
                      end
                end
              module List :
                sig
                  val all : 'a t list -> 'a list t
                  val all_ignore : 'a t list -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
                  val map : 'a list -> f:('-> 'b t) -> 'b list t
                  val iter :
                    'a list -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'a list -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce : 'a list -> f:('-> '-> 'a t) -> 'a option t
                  val exists : 'a list -> f:('-> bool t) -> bool t
                  val for_all : 'a list -> f:('-> bool t) -> bool t
                  val count : 'a list -> f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b list -> f:('-> 'a t) -> 'a t
                  val find : 'a list -> f:('-> bool t) -> 'a option t
                  val find_map :
                    'a list -> f:('-> 'b option t) -> 'b option t
                  val filter : 'a list -> f:('-> bool t) -> 'a list t
                  val filter_map :
                    'a list -> f:('-> 'b option t) -> 'b list t
                end
              module Seq :
                sig
                  val all :
                    'a t Core_kernel.Std.Sequence.t ->
                    'Core_kernel.Std.Sequence.t t
                  val all_ignore :
                    'a t Core_kernel.Std.Sequence.t -> Monoid.Unit.t t
                  val sequence :
                    Monoid.Unit.t t Core_kernel.Std.Sequence.t ->
                    Monoid.Unit.t t
                  val map :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> 'b t) -> 'Core_kernel.Std.Sequence.t t
                  val iter :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'Core_kernel.Std.Sequence.t ->
                    init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'Core_kernel.Std.Sequence.t ->
                    init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> '-> 'a t) -> 'a option t
                  val exists :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> bool t) -> bool t
                  val for_all :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> bool t) -> bool t
                  val count :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Core_kernel.Std.Sequence.t -> f:('-> 'a t) -> 'a t
                  val find :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> bool t) -> 'a option t
                  val find_map :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> 'b option t) -> 'b option t
                  val filter :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> bool t) -> 'Core_kernel.Std.Sequence.t t
                  val filter_map :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> 'b option t) -> 'Core_kernel.Std.Sequence.t t
                end
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Monad_infix :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                end
              val bind : 'a t -> f:('-> 'b t) -> 'b t
              val return : '-> 'a t
              val map : 'a t -> f:('-> 'b) -> 'b t
              val join : 'a t t -> 'a t
              val ignore_m : 'a t -> Monoid.Unit.t t
              val all : 'a t list -> 'a list t
              val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val bind : 'a t -> f:('-> 'b t) -> 'b t
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val both : 'a t -> 'b t -> ('a * 'b) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Syntax :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
            end
          module type S2 =
            sig
              type ('a, 'e) t
              val void :
                ('a, 'e) Monads.Std.Monad.S2.t ->
                (unit, 'e) Monads.Std.Monad.S2.t
              val sequence :
                (unit, 'e) Monads.Std.Monad.S2.t list ->
                (unit, 'e) Monads.Std.Monad.S2.t
              val forever :
                ('a, 'e) Monads.Std.Monad.S2.t ->
                ('b, 'e) Monads.Std.Monad.S2.t
              module Fn :
                sig
                  val id : '-> ('a, 'e) Monads.Std.Monad.S2.t
                  val ignore :
                    ('a, 'e) Monads.Std.Monad.S2.t ->
                    (unit, 'e) Monads.Std.Monad.S2.t
                  val nothing : unit -> (unit, 'e) Monads.Std.Monad.S2.t
                  val non :
                    ('-> (bool, 'e) Monads.Std.Monad.S2.t) ->
                    '-> (bool, 'e) Monads.Std.Monad.S2.t
                  val apply_n_times :
                    n:int ->
                    ('-> ('a, 'e) Monads.Std.Monad.S2.t) ->
                    '-> ('a, 'e) Monads.Std.Monad.S2.t
                  val compose :
                    ('-> ('c, 'e) Monads.Std.Monad.S2.t) ->
                    ('-> ('b, 'e) Monads.Std.Monad.S2.t) ->
                    '-> ('c, 'e) Monads.Std.Monad.S2.t
                end
              module Pair :
                sig
                  val fst :
                    ('a * 'b, 'e) Monads.Std.Monad.S2.t ->
                    ('a, 'e) Monads.Std.Monad.S2.t
                  val snd :
                    ('a * 'b, 'e) Monads.Std.Monad.S2.t ->
                    ('b, 'e) Monads.Std.Monad.S2.t
                end
              module Triple :
                sig
                  val fst :
                    ('a * 'b * 'c, 'e) Monads.Std.Monad.S2.t ->
                    ('a, 'e) Monads.Std.Monad.S2.t
                  val snd :
                    ('a * 'b * 'c, 'e) Monads.Std.Monad.S2.t ->
                    ('b, 'e) Monads.Std.Monad.S2.t
                  val trd :
                    ('a * 'b * 'c, 'e) Monads.Std.Monad.S2.t ->
                    ('c, 'e) Monads.Std.Monad.S2.t
                end
              module Lift :
                sig
                  val nullary : '-> ('a, 'e) Monads.Std.Monad.S2.t
                  val unary :
                    ('-> 'b) ->
                    ('a, 'e) Monads.Std.Monad.S2.t ->
                    ('b, 'e) Monads.Std.Monad.S2.t
                  val binary :
                    ('-> '-> 'c) ->
                    ('a, 'e) Monads.Std.Monad.S2.t ->
                    ('b, 'e) Monads.Std.Monad.S2.t ->
                    ('c, 'e) Monads.Std.Monad.S2.t
                  val ternary :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) Monads.Std.Monad.S2.t ->
                    ('b, 'e) Monads.Std.Monad.S2.t ->
                    ('c, 'e) Monads.Std.Monad.S2.t ->
                    ('d, 'e) Monads.Std.Monad.S2.t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) Monads.Std.Monad.S2.t ->
                    ('b, 's) Monads.Std.Monad.S2.t ->
                    ('c, 's) Monads.Std.Monad.S2.t ->
                    ('d, 's) Monads.Std.Monad.S2.t ->
                    ('e, 's) Monads.Std.Monad.S2.t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) Monads.Std.Monad.S2.t ->
                    ('b, 's) Monads.Std.Monad.S2.t ->
                    ('c, 's) Monads.Std.Monad.S2.t ->
                    ('d, 's) Monads.Std.Monad.S2.t ->
                    ('e, 's) Monads.Std.Monad.S2.t ->
                    ('f, 's) Monads.Std.Monad.S2.t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(unit -> (unit, 's) Monads.Std.Monad.S2.t) ->
                    f:(unit -> ('a, 's) Monads.Std.Monad.S2.t) ->
                    catch:(exn -> ('a, 's) Monads.Std.Monad.S2.t) ->
                    ('a, 's) Monads.Std.Monad.S2.t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : ('a, 'e) t t -> ('a t, 'e) t
                      val all_ignore : ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
                      val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                      val iter :
                        'a t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'a t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'a t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'a t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'a t ->
                        f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                      val exists :
                        'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'a t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'a t -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
                      val find_map :
                        'a t ->
                        f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                      val filter :
                        'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                      val filter_map :
                        'a t -> f:('-> ('b option, 'e) t) -> ('b t, 'e) t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('a option, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('b option, 'e) t) -> ('T.t, 'e) t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('a option, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('b option, 'e) t) -> ('T.t, 'e) t
                      end
                end
              module List :
                sig
                  val all : ('a, 'e) t list -> ('a list, 'e) t
                  val all_ignore : ('a, 'e) t list -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                  val map :
                    'a list -> f:('-> ('b, 'e) t) -> ('b list, 'e) t
                  val iter :
                    'a list ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'a list ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'a list ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'a list ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'a list ->
                    f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                  val exists :
                    'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'a list -> f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b list -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'a list -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
                  val find_map :
                    'a list ->
                    f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                  val filter :
                    'a list -> f:('-> (bool, 'e) t) -> ('a list, 'e) t
                  val filter_map :
                    'a list -> f:('-> ('b option, 'e) t) -> ('b list, 'e) t
                end
              module Seq :
                sig
                  val all :
                    ('a, 'e) t Core_kernel.Std.Sequence.t ->
                    ('Core_kernel.Std.Sequence.t, 'e) t
                  val all_ignore :
                    ('a, 'e) t Core_kernel.Std.Sequence.t ->
                    (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t Core_kernel.Std.Sequence.t ->
                    (Monoid.Unit.t, 'e) t
                  val map :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> ('b, 'e) t) ->
                    ('Core_kernel.Std.Sequence.t, 'e) t
                  val iter :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'Core_kernel.Std.Sequence.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'Core_kernel.Std.Sequence.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                  val exists :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> (bool, 'e) t) -> ('a option, 'e) t
                  val find_map :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                  val filter :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> (bool, 'e) t) ->
                    ('Core_kernel.Std.Sequence.t, 'e) t
                  val filter_map :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> ('b option, 'e) t) ->
                    ('Core_kernel.Std.Sequence.t, 'e) t
                end
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val bind :
                        ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                      val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Monad_infix :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                end
              val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
              val return : '-> ('a, 'b) t
              val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
              val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
              val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val all : ('a, 'e) t list -> ('a list, 'e) t
              val all_ignore :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              module Syntax :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  val ( >=> ) :
                    ('-> ('b, 'e) t) ->
                    ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                  val ( !! ) : '-> ('a, 'e) t
                  val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
            end
          module type Core = Core_kernel.Std.Monad.S
          module type Core2 = Core_kernel.Std.Monad.S2
          module type Minimal =
            sig
              type 'a t
              val return : '-> 'Monads.Std.Monad.Minimal.t
              val bind :
                'Monads.Std.Monad.Minimal.t ->
                ('-> 'Monads.Std.Monad.Minimal.t) ->
                'Monads.Std.Monad.Minimal.t
            end
          module type Minimal2 =
            sig
              type ('a, 'e) t
              val return : '-> ('a, 'e) Monads.Std.Monad.Minimal2.t
              val bind :
                ('a, 'e) Monads.Std.Monad.Minimal2.t ->
                ('-> ('b, 'e) Monads.Std.Monad.Minimal2.t) ->
                ('b, 'e) Monads.Std.Monad.Minimal2.t
            end
          module Make :
            functor (M : Basic->
              sig
                val void : 'M.t -> Monoid.Unit.t M.t
                val sequence : Monoid.Unit.t M.t list -> Monoid.Unit.t M.t
                val forever : 'M.t -> 'M.t
                module Fn :
                  sig
                    val id : '-> 'M.t
                    val ignore : 'M.t -> Monoid.Unit.t M.t
                    val nothing : Monoid.Unit.t -> Monoid.Unit.t M.t
                    val non : ('-> bool M.t) -> '-> bool M.t
                    val apply_n_times :
                      n:Monoid.Int.t -> ('-> 'M.t) -> '-> 'M.t
                    val compose :
                      ('-> 'M.t) -> ('-> 'M.t) -> '-> 'M.t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b) M.t -> 'M.t
                    val snd : ('a * 'b) M.t -> 'M.t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c) M.t -> 'M.t
                    val snd : ('a * 'b * 'c) M.t -> 'M.t
                    val trd : ('a * 'b * 'c) M.t -> 'M.t
                  end
                module Lift :
                  sig
                    val nullary : '-> 'M.t
                    val unary : ('-> 'b) -> 'M.t -> 'M.t
                    val binary :
                      ('-> '-> 'c) -> 'M.t -> 'M.t -> 'M.t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      'M.t -> 'M.t -> 'M.t -> 'M.t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'M.t ->
                      'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> Monoid.Unit.t M.t) ->
                      f:(Monoid.Unit.t -> 'M.t) ->
                      catch:(exn -> 'M.t) -> 'M.t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : 'M.t t -> 'a t M.t
                        val all_ignore : 'M.t t -> Monoid.Unit.t M.t
                        val sequence :
                          Monoid.Unit.t M.t t -> Monoid.Unit.t M.t
                        val map : 'a t -> f:('-> 'M.t) -> 'b t M.t
                        val iter :
                          'a t ->
                          f:('-> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t
                        val fold :
                          'a t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                        val fold_left :
                          'a t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                        val fold_right :
                          'a t -> f:('-> '-> 'M.t) -> init:'-> 'M.t
                        val reduce :
                          'a t -> f:('-> '-> 'M.t) -> 'a option M.t
                        val exists : 'a t -> f:('-> bool M.t) -> bool M.t
                        val for_all : 'a t -> f:('-> bool M.t) -> bool M.t
                        val count :
                          'a t -> f:('-> bool M.t) -> Monoid.Int.t M.t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t -> f:('-> 'M.t) -> 'M.t
                        val find :
                          'a t -> f:('-> bool M.t) -> 'a option M.t
                        val find_map :
                          'a t -> f:('-> 'b option M.t) -> 'b option M.t
                        val filter : 'a t -> f:('-> bool M.t) -> 'a t M.t
                        val filter_map :
                          'a t -> f:('-> 'b option M.t) -> 'b t M.t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all : 'M.t T.t -> 'T.t M.t
                          val all_ignore : 'M.t T.t -> Monoid.Unit.t M.t
                          val sequence :
                            Monoid.Unit.t M.t T.t -> Monoid.Unit.t M.t
                          val map : 'T.t -> f:('-> 'M.t) -> 'T.t M.t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t
                          val fold :
                            'T.t ->
                            init:'-> f:('-> '-> 'M.t) -> 'M.t
                          val fold_left :
                            'T.t ->
                            init:'-> f:('-> '-> 'M.t) -> 'M.t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'M.t) -> init:'-> 'M.t
                          val reduce :
                            'T.t -> f:('-> '-> 'M.t) -> 'a option M.t
                          val exists :
                            'T.t -> f:('-> bool M.t) -> bool M.t
                          val for_all :
                            'T.t -> f:('-> bool M.t) -> bool M.t
                          val count :
                            'T.t -> f:('-> bool M.t) -> Monoid.Int.t M.t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> 'M.t) -> 'M.t
                          val find :
                            'T.t -> f:('-> bool M.t) -> 'a option M.t
                          val find_map :
                            'T.t ->
                            f:('-> 'b option M.t) -> 'b option M.t
                          val filter :
                            'T.t -> f:('-> bool M.t) -> 'T.t M.t
                          val filter_map :
                            'T.t -> f:('-> 'b option M.t) -> 'T.t M.t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all : 'M.t T.t -> 'T.t M.t
                          val all_ignore : 'M.t T.t -> Monoid.Unit.t M.t
                          val sequence :
                            Monoid.Unit.t M.t T.t -> Monoid.Unit.t M.t
                          val map : 'T.t -> f:('-> 'M.t) -> 'T.t M.t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t
                          val fold :
                            'T.t ->
                            init:'-> f:('-> '-> 'M.t) -> 'M.t
                          val fold_left :
                            'T.t ->
                            init:'-> f:('-> '-> 'M.t) -> 'M.t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> 'M.t) -> init:'-> 'M.t
                          val reduce :
                            'T.t -> f:('-> '-> 'M.t) -> 'a option M.t
                          val exists :
                            'T.t -> f:('-> bool M.t) -> bool M.t
                          val for_all :
                            'T.t -> f:('-> bool M.t) -> bool M.t
                          val count :
                            'T.t -> f:('-> bool M.t) -> Monoid.Int.t M.t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> 'M.t) -> 'M.t
                          val find :
                            'T.t -> f:('-> bool M.t) -> 'a option M.t
                          val find_map :
                            'T.t ->
                            f:('-> 'b option M.t) -> 'b option M.t
                          val filter :
                            'T.t -> f:('-> bool M.t) -> 'T.t M.t
                          val filter_map :
                            'T.t -> f:('-> 'b option M.t) -> 'T.t M.t
                        end
                  end
                module List :
                  sig
                    val all : 'M.t list -> 'a list M.t
                    val all_ignore : 'M.t list -> Monoid.Unit.t M.t
                    val sequence :
                      Monoid.Unit.t M.t list -> Monoid.Unit.t M.t
                    val map : 'a list -> f:('-> 'M.t) -> 'b list M.t
                    val iter :
                      'a list ->
                      f:('-> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t
                    val fold :
                      'a list -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                    val fold_left :
                      'a list -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                    val fold_right :
                      'a list -> f:('-> '-> 'M.t) -> init:'-> 'M.t
                    val reduce :
                      'a list -> f:('-> '-> 'M.t) -> 'a option M.t
                    val exists : 'a list -> f:('-> bool M.t) -> bool M.t
                    val for_all : 'a list -> f:('-> bool M.t) -> bool M.t
                    val count :
                      'a list -> f:('-> bool M.t) -> Monoid.Int.t M.t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b list -> f:('-> 'M.t) -> 'M.t
                    val find : 'a list -> f:('-> bool M.t) -> 'a option M.t
                    val find_map :
                      'a list -> f:('-> 'b option M.t) -> 'b option M.t
                    val filter : 'a list -> f:('-> bool M.t) -> 'a list M.t
                    val filter_map :
                      'a list -> f:('-> 'b option M.t) -> 'b list M.t
                  end
                module Seq :
                  sig
                    val all :
                      'M.t Core_kernel.Std.Sequence.t ->
                      'Core_kernel.Std.Sequence.t M.t
                    val all_ignore :
                      'M.t Core_kernel.Std.Sequence.t -> Monoid.Unit.t M.t
                    val sequence :
                      Monoid.Unit.t M.t Core_kernel.Std.Sequence.t ->
                      Monoid.Unit.t M.t
                    val map :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> 'M.t) -> 'Core_kernel.Std.Sequence.t M.t
                    val iter :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t
                    val fold :
                      'Core_kernel.Std.Sequence.t ->
                      init:'-> f:('-> '-> 'M.t) -> 'M.t
                    val fold_left :
                      'Core_kernel.Std.Sequence.t ->
                      init:'-> f:('-> '-> 'M.t) -> 'M.t
                    val fold_right :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> '-> 'M.t) -> init:'-> 'M.t
                    val reduce :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> '-> 'M.t) -> 'a option M.t
                    val exists :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool M.t) -> bool M.t
                    val for_all :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool M.t) -> bool M.t
                    val count :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool M.t) -> Monoid.Int.t M.t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> 'M.t) -> 'M.t
                    val find :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool M.t) -> 'a option M.t
                    val find_map :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> 'b option M.t) -> 'b option M.t
                    val filter :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool M.t) -> 'Core_kernel.Std.Sequence.t M.t
                    val filter_map :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> 'b option M.t) ->
                      'Core_kernel.Std.Sequence.t M.t
                  end
                val ( >=> ) :
                  ('-> 'M.t) -> ('-> 'M.t) -> '-> 'M.t
                val ( !! ) : '-> 'M.t
                val ( !$ ) : ('-> 'b) -> 'M.t -> 'M.t
                val ( !$$ ) : ('-> '-> 'c) -> 'M.t -> 'M.t -> 'M.t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  'M.t -> 'M.t -> 'M.t -> 'M.t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t
                val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t
                val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t
                module Monad_infix :
                  sig
                    val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t
                    val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t
                  end
                val bind : 'M.t -> f:('-> 'M.t) -> 'M.t
                val return : '-> 'M.t
                val map : 'M.t -> f:('-> 'b) -> 'M.t
                val join : 'M.t M.t -> 'M.t
                val ignore_m : 'M.t -> Monoid.Unit.t M.t
                val all : 'M.t list -> 'a list M.t
                val all_ignore : Monoid.Unit.t M.t list -> Monoid.Unit.t M.t
                module Let_syntax :
                  sig
                    val return : '-> 'M.t
                    val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t
                    val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t
                    module Let_syntax :
                      sig
                        val return : '-> 'M.t
                        val bind : 'M.t -> f:('-> 'M.t) -> 'M.t
                        val map : 'M.t -> f:('-> 'b) -> 'M.t
                        val both : 'M.t -> 'M.t -> ('a * 'b) M.t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Syntax :
                  sig
                    val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t
                    val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t
                    val ( >=> ) :
                      ('-> 'M.t) -> ('-> 'M.t) -> '-> 'M.t
                    val ( !! ) : '-> 'M.t
                    val ( !$ ) : ('-> 'b) -> 'M.t -> 'M.t
                    val ( !$$ ) :
                      ('-> '-> 'c) -> 'M.t -> 'M.t -> 'M.t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'M.t -> 'M.t -> 'M.t -> 'M.t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'M.t ->
                      'M.t -> 'M.t -> 'M.t -> 'M.t -> 'M.t
                  end
              end
          module Make2 :
            functor (M : Basic2->
              sig
                val void : ('a, 'e) M.t -> (Monoid.Unit.t, 'e) M.t
                val sequence :
                  (Monoid.Unit.t, 'e) M.t list -> (Monoid.Unit.t, 'e) M.t
                val forever : ('a, 'e) M.t -> ('b, 'e) M.t
                module Fn :
                  sig
                    val id : '-> ('a, 'e) M.t
                    val ignore : ('a, 'e) M.t -> (Monoid.Unit.t, 'e) M.t
                    val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) M.t
                    val non : ('-> (bool, 'e) M.t) -> '-> (bool, 'e) M.t
                    val apply_n_times :
                      n:Monoid.Int.t ->
                      ('-> ('a, 'e) M.t) -> '-> ('a, 'e) M.t
                    val compose :
                      ('-> ('c, 'e) M.t) ->
                      ('-> ('b, 'e) M.t) -> '-> ('c, 'e) M.t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b, 'e) M.t -> ('a, 'e) M.t
                    val snd : ('a * 'b, 'e) M.t -> ('b, 'e) M.t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c, 'e) M.t -> ('a, 'e) M.t
                    val snd : ('a * 'b * 'c, 'e) M.t -> ('b, 'e) M.t
                    val trd : ('a * 'b * 'c, 'e) M.t -> ('c, 'e) M.t
                  end
                module Lift :
                  sig
                    val nullary : '-> ('a, 'e) M.t
                    val unary : ('-> 'b) -> ('a, 'e) M.t -> ('b, 'e) M.t
                    val binary :
                      ('-> '-> 'c) ->
                      ('a, 'e) M.t -> ('b, 'e) M.t -> ('c, 'e) M.t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) M.t ->
                      ('b, 'e) M.t -> ('c, 'e) M.t -> ('d, 'e) M.t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) M.t ->
                      ('b, 's) M.t ->
                      ('c, 's) M.t -> ('d, 's) M.t -> ('e, 's) M.t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) M.t ->
                      ('b, 's) M.t ->
                      ('c, 's) M.t ->
                      ('d, 's) M.t -> ('e, 's) M.t -> ('f, 's) M.t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) M.t) ->
                      f:(Monoid.Unit.t -> ('a, 's) M.t) ->
                      catch:(exn -> ('a, 's) M.t) -> ('a, 's) M.t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : ('a, 'e) M.t t -> ('a t, 'e) M.t
                        val all_ignore :
                          ('a, 'e) M.t t -> (Monoid.Unit.t, 'e) M.t
                        val sequence :
                          (Monoid.Unit.t, 'e) M.t t ->
                          (Monoid.Unit.t, 'e) M.t
                        val map :
                          'a t -> f:('-> ('b, 'e) M.t) -> ('b t, 'e) M.t
                        val iter :
                          'a t ->
                          f:('-> (Monoid.Unit.t, 'e) M.t) ->
                          (Monoid.Unit.t, 'e) M.t
                        val fold :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                        val fold_left :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                        val fold_right :
                          'a t ->
                          f:('-> '-> ('b, 'e) M.t) ->
                          init:'-> ('b, 'e) M.t
                        val reduce :
                          'a t ->
                          f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t
                        val exists :
                          'a t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                        val for_all :
                          'a t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                        val count :
                          'a t ->
                          f:('-> (bool, 'e) M.t) -> (Monoid.Int.t, 'e) M.t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t -> f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t
                        val find :
                          'a t ->
                          f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t
                        val find_map :
                          'a t ->
                          f:('-> ('b option, 'e) M.t) ->
                          ('b option, 'e) M.t
                        val filter :
                          'a t -> f:('-> (bool, 'e) M.t) -> ('a t, 'e) M.t
                        val filter_map :
                          'a t ->
                          f:('-> ('b option, 'e) M.t) -> ('b t, 'e) M.t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all : ('a, 'e) M.t T.t -> ('T.t, 'e) M.t
                          val all_ignore :
                            ('a, 'e) M.t T.t -> (Monoid.Unit.t, 'e) M.t
                          val sequence :
                            (Monoid.Unit.t, 'e) M.t T.t ->
                            (Monoid.Unit.t, 'e) M.t
                          val map :
                            'T.t ->
                            f:('-> ('b, 'e) M.t) -> ('T.t, 'e) M.t
                          val iter :
                            'T.t ->
                            f:('-> (Monoid.Unit.t, 'e) M.t) ->
                            (Monoid.Unit.t, 'e) M.t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) M.t) ->
                            init:'-> ('b, 'e) M.t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) M.t) ->
                            ('a option, 'e) M.t
                          val exists :
                            'T.t ->
                            f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                          val for_all :
                            'T.t ->
                            f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) M.t) ->
                            (Monoid.Int.t, 'e) M.t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t
                          val find_map :
                            'T.t ->
                            f:('-> ('b option, 'e) M.t) ->
                            ('b option, 'e) M.t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) M.t) -> ('T.t, 'e) M.t
                          val filter_map :
                            'T.t ->
                            f:('-> ('b option, 'e) M.t) -> ('T.t, 'e) M.t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all : ('a, 'e) M.t T.t -> ('T.t, 'e) M.t
                          val all_ignore :
                            ('a, 'e) M.t T.t -> (Monoid.Unit.t, 'e) M.t
                          val sequence :
                            (Monoid.Unit.t, 'e) M.t T.t ->
                            (Monoid.Unit.t, 'e) M.t
                          val map :
                            'T.t ->
                            f:('-> ('b, 'e) M.t) -> ('T.t, 'e) M.t
                          val iter :
                            'T.t ->
                            f:('-> (Monoid.Unit.t, 'e) M.t) ->
                            (Monoid.Unit.t, 'e) M.t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) M.t) ->
                            init:'-> ('b, 'e) M.t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) M.t) ->
                            ('a option, 'e) M.t
                          val exists :
                            'T.t ->
                            f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                          val for_all :
                            'T.t ->
                            f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) M.t) ->
                            (Monoid.Int.t, 'e) M.t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t
                          val find_map :
                            'T.t ->
                            f:('-> ('b option, 'e) M.t) ->
                            ('b option, 'e) M.t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) M.t) -> ('T.t, 'e) M.t
                          val filter_map :
                            'T.t ->
                            f:('-> ('b option, 'e) M.t) -> ('T.t, 'e) M.t
                        end
                  end
                module List :
                  sig
                    val all : ('a, 'e) M.t list -> ('a list, 'e) M.t
                    val all_ignore :
                      ('a, 'e) M.t list -> (Monoid.Unit.t, 'e) M.t
                    val sequence :
                      (Monoid.Unit.t, 'e) M.t list -> (Monoid.Unit.t, 'e) M.t
                    val map :
                      'a list -> f:('-> ('b, 'e) M.t) -> ('b list, 'e) M.t
                    val iter :
                      'a list ->
                      f:('-> (Monoid.Unit.t, 'e) M.t) ->
                      (Monoid.Unit.t, 'e) M.t
                    val fold :
                      'a list ->
                      init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                    val fold_left :
                      'a list ->
                      init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                    val fold_right :
                      'a list ->
                      f:('-> '-> ('b, 'e) M.t) -> init:'-> ('b, 'e) M.t
                    val reduce :
                      'a list ->
                      f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t
                    val exists :
                      'a list -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                    val for_all :
                      'a list -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                    val count :
                      'a list ->
                      f:('-> (bool, 'e) M.t) -> (Monoid.Int.t, 'e) M.t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b list -> f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t
                    val find :
                      'a list ->
                      f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t
                    val find_map :
                      'a list ->
                      f:('-> ('b option, 'e) M.t) -> ('b option, 'e) M.t
                    val filter :
                      'a list ->
                      f:('-> (bool, 'e) M.t) -> ('a list, 'e) M.t
                    val filter_map :
                      'a list ->
                      f:('-> ('b option, 'e) M.t) -> ('b list, 'e) M.t
                  end
                module Seq :
                  sig
                    val all :
                      ('a, 'e) M.t Core_kernel.Std.Sequence.t ->
                      ('Core_kernel.Std.Sequence.t, 'e) M.t
                    val all_ignore :
                      ('a, 'e) M.t Core_kernel.Std.Sequence.t ->
                      (Monoid.Unit.t, 'e) M.t
                    val sequence :
                      (Monoid.Unit.t, 'e) M.t Core_kernel.Std.Sequence.t ->
                      (Monoid.Unit.t, 'e) M.t
                    val map :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> ('b, 'e) M.t) ->
                      ('Core_kernel.Std.Sequence.t, 'e) M.t
                    val iter :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> (Monoid.Unit.t, 'e) M.t) ->
                      (Monoid.Unit.t, 'e) M.t
                    val fold :
                      'Core_kernel.Std.Sequence.t ->
                      init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                    val fold_left :
                      'Core_kernel.Std.Sequence.t ->
                      init:'-> f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                    val fold_right :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> '-> ('b, 'e) M.t) -> init:'-> ('b, 'e) M.t
                    val reduce :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t
                    val exists :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                    val for_all :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                    val count :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> (bool, 'e) M.t) -> (Monoid.Int.t, 'e) M.t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t
                    val find :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t
                    val find_map :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> ('b option, 'e) M.t) -> ('b option, 'e) M.t
                    val filter :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> (bool, 'e) M.t) ->
                      ('Core_kernel.Std.Sequence.t, 'e) M.t
                    val filter_map :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> ('b option, 'e) M.t) ->
                      ('Core_kernel.Std.Sequence.t, 'e) M.t
                  end
                val ( >=> ) :
                  ('-> ('b, 'e) M.t) ->
                  ('-> ('c, 'e) M.t) -> '-> ('c, 'e) M.t
                val ( !! ) : '-> ('a, 'e) M.t
                val ( !$ ) : ('-> 'b) -> ('a, 'e) M.t -> ('b, 'e) M.t
                val ( !$$ ) :
                  ('-> '-> 'c) ->
                  ('a, 'e) M.t -> ('b, 'e) M.t -> ('c, 'e) M.t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) M.t ->
                  ('b, 'e) M.t -> ('c, 'e) M.t -> ('d, 'e) M.t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) M.t ->
                  ('b, 's) M.t ->
                  ('c, 's) M.t -> ('d, 's) M.t -> ('e, 's) M.t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) M.t ->
                  ('b, 's) M.t ->
                  ('c, 's) M.t ->
                  ('d, 's) M.t -> ('e, 's) M.t -> ('f, 's) M.t
                val ( >>= ) :
                  ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) M.t
                    val ( >>= ) :
                      ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                    val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) M.t
                        val bind :
                          ('a, 'e) M.t ->
                          f:('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                        val map :
                          ('a, 'e) M.t -> f:('-> 'b) -> ('b, 'e) M.t
                        val both :
                          ('a, 'e) M.t -> ('b, 'e) M.t -> ('a * 'b, 'e) M.t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                    val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t
                  end
                val bind :
                  ('a, 'e) M.t -> f:('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                val return : '-> ('a, 'b) M.t
                val map : ('a, 'e) M.t -> f:('-> 'b) -> ('b, 'e) M.t
                val join : (('a, 'e) M.t, 'e) M.t -> ('a, 'e) M.t
                val ignore_m : ('a, 'e) M.t -> (Monoid.Unit.t, 'e) M.t
                val all : ('a, 'e) M.t list -> ('a list, 'e) M.t
                val all_ignore :
                  (Monoid.Unit.t, 'e) M.t list -> (Monoid.Unit.t, 'e) M.t
                module Syntax :
                  sig
                    val ( >>= ) :
                      ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                    val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t
                    val ( >=> ) :
                      ('-> ('b, 'e) M.t) ->
                      ('-> ('c, 'e) M.t) -> '-> ('c, 'e) M.t
                    val ( !! ) : '-> ('a, 'e) M.t
                    val ( !$ ) : ('-> 'b) -> ('a, 'e) M.t -> ('b, 'e) M.t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      ('a, 'e) M.t -> ('b, 'e) M.t -> ('c, 'e) M.t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) M.t ->
                      ('b, 'e) M.t -> ('c, 'e) M.t -> ('d, 'e) M.t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) M.t ->
                      ('b, 's) M.t ->
                      ('c, 's) M.t -> ('d, 's) M.t -> ('e, 's) M.t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) M.t ->
                      ('b, 's) M.t ->
                      ('c, 's) M.t ->
                      ('d, 's) M.t -> ('e, 's) M.t -> ('f, 's) M.t
                  end
              end
          module Core :
            functor (M : Core->
              sig
                type 'a t = 'M.t
                val void : 'a t -> Monoid.Unit.t t
                val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
                val forever : 'a t -> 'b t
                module Fn :
                  sig
                    val id : '-> 'a t
                    val ignore : 'a t -> Monoid.Unit.t t
                    val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                    val non : ('-> bool t) -> '-> bool t
                    val apply_n_times :
                      n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                    val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b) t -> 'a t
                    val snd : ('a * 'b) t -> 'b t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c) t -> 'a t
                    val snd : ('a * 'b * 'c) t -> 'b t
                    val trd : ('a * 'b * 'c) t -> 'c t
                  end
                module Lift :
                  sig
                    val nullary : '-> 'a t
                    val unary : ('-> 'b) -> 'a t -> 'b t
                    val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                    val ternary :
                      ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      'a t -> 'b t -> 'c t -> 'd t -> 'e t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                      f:(Monoid.Unit.t -> 'a t) ->
                      catch:(exn -> 'a t) -> 'a t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : 'M.t t -> 'a t M.t
                        val all_ignore : 'M.t t -> Monoid.Unit.t M.t
                        val sequence :
                          Monoid.Unit.t M.t t -> Monoid.Unit.t M.t
                        val map : 'a t -> f:('-> 'M.t) -> 'b t M.t
                        val iter :
                          'a t ->
                          f:('-> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t
                        val fold :
                          'a t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                        val fold_left :
                          'a t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                        val fold_right :
                          'a t -> f:('-> '-> 'M.t) -> init:'-> 'M.t
                        val reduce :
                          'a t -> f:('-> '-> 'M.t) -> 'a option M.t
                        val exists : 'a t -> f:('-> bool M.t) -> bool M.t
                        val for_all : 'a t -> f:('-> bool M.t) -> bool M.t
                        val count :
                          'a t -> f:('-> bool M.t) -> Monoid.Int.t M.t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t -> f:('-> 'M.t) -> 'M.t
                        val find :
                          'a t -> f:('-> bool M.t) -> 'a option M.t
                        val find_map :
                          'a t -> f:('-> 'b option M.t) -> 'b option M.t
                        val filter : 'a t -> f:('-> bool M.t) -> 'a t M.t
                        val filter_map :
                          'a t -> f:('-> 'b option M.t) -> 'b t M.t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all : 'a t T.t -> 'T.t t
                          val all_ignore : 'a t T.t -> Monoid.Unit.t t
                          val sequence :
                            Monoid.Unit.t t T.t -> Monoid.Unit.t t
                          val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                          val fold :
                            'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_left :
                            'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_right :
                            'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                          val reduce :
                            'T.t -> f:('-> '-> 'a t) -> 'a option t
                          val exists : 'T.t -> f:('-> bool t) -> bool t
                          val for_all : 'T.t -> f:('-> bool t) -> bool t
                          val count :
                            'T.t -> f:('-> bool t) -> Monoid.Int.t t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> 'a t) -> 'a t
                          val find :
                            'T.t -> f:('-> bool t) -> 'a option t
                          val find_map :
                            'T.t -> f:('-> 'b option t) -> 'b option t
                          val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                          val filter_map :
                            'T.t -> f:('-> 'b option t) -> 'T.t t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all : 'a t T.t -> 'T.t t
                          val all_ignore : 'a t T.t -> Monoid.Unit.t t
                          val sequence :
                            Monoid.Unit.t t T.t -> Monoid.Unit.t t
                          val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                          val fold :
                            'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_left :
                            'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_right :
                            'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                          val reduce :
                            'T.t -> f:('-> '-> 'a t) -> 'a option t
                          val exists : 'T.t -> f:('-> bool t) -> bool t
                          val for_all : 'T.t -> f:('-> bool t) -> bool t
                          val count :
                            'T.t -> f:('-> bool t) -> Monoid.Int.t t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> 'a t) -> 'a t
                          val find :
                            'T.t -> f:('-> bool t) -> 'a option t
                          val find_map :
                            'T.t -> f:('-> 'b option t) -> 'b option t
                          val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                          val filter_map :
                            'T.t -> f:('-> 'b option t) -> 'T.t t
                        end
                  end
                module List :
                  sig
                    val all : 'a t list -> 'a list t
                    val all_ignore : 'a t list -> Monoid.Unit.t t
                    val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
                    val map : 'a list -> f:('-> 'b t) -> 'b list t
                    val iter :
                      'a list -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                    val fold :
                      'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'a list -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'a list -> f:('-> '-> 'a t) -> 'a option t
                    val exists : 'a list -> f:('-> bool t) -> bool t
                    val for_all : 'a list -> f:('-> bool t) -> bool t
                    val count : 'a list -> f:('-> bool t) -> Monoid.Int.t t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b list -> f:('-> 'a t) -> 'a t
                    val find : 'a list -> f:('-> bool t) -> 'a option t
                    val find_map :
                      'a list -> f:('-> 'b option t) -> 'b option t
                    val filter : 'a list -> f:('-> bool t) -> 'a list t
                    val filter_map :
                      'a list -> f:('-> 'b option t) -> 'b list t
                  end
                module Seq :
                  sig
                    val all :
                      'a t Core_kernel.Std.Sequence.t ->
                      'Core_kernel.Std.Sequence.t t
                    val all_ignore :
                      'a t Core_kernel.Std.Sequence.t -> Monoid.Unit.t t
                    val sequence :
                      Monoid.Unit.t t Core_kernel.Std.Sequence.t ->
                      Monoid.Unit.t t
                    val map :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> 'b t) -> 'Core_kernel.Std.Sequence.t t
                    val iter :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                    val fold :
                      'Core_kernel.Std.Sequence.t ->
                      init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'Core_kernel.Std.Sequence.t ->
                      init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> '-> 'a t) -> 'a option t
                    val exists :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool t) -> bool t
                    val for_all :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool t) -> bool t
                    val count :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool t) -> Monoid.Int.t t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Core_kernel.Std.Sequence.t -> f:('-> 'a t) -> 'a t
                    val find :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool t) -> 'a option t
                    val find_map :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> 'b option t) -> 'b option t
                    val filter :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool t) -> 'Core_kernel.Std.Sequence.t t
                    val filter_map :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> 'b option t) ->
                      'Core_kernel.Std.Sequence.t t
                  end
                val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                val ( !! ) : '-> 'a t
                val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'a t -> 'b t -> 'c t -> 'd t -> 'e t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                module Monad_infix :
                  sig
                    val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                    val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  end
                val bind : 'a t -> f:('-> 'b t) -> 'b t
                val return : '-> 'a t
                val map : 'a t -> f:('-> 'b) -> 'b t
                val join : 'a t t -> 'a t
                val ignore_m : 'a t -> Monoid.Unit.t t
                val all : 'a t list -> 'a list t
                val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
                module Let_syntax :
                  sig
                    val return : '-> 'a t
                    val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                    val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                    module Let_syntax :
                      sig
                        val return : '-> 'a t
                        val bind : 'a t -> f:('-> 'b t) -> 'b t
                        val map : 'a t -> f:('-> 'b) -> 'b t
                        val both : 'a t -> 'b t -> ('a * 'b) t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Syntax :
                  sig
                    val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                    val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                    val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                    val ( !! ) : '-> 'a t
                    val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                    val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'a t -> 'b t -> 'c t -> 'd t -> 'e t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                  end
              end
          module Core2 :
            functor (M : Core2->
              sig
                type ('a, 'e) t = ('a, 'e) M.t
                val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                val sequence :
                  (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                val forever : ('a, 'e) t -> ('b, 'e) t
                module Fn :
                  sig
                    val id : '-> ('a, 'e) t
                    val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                    val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                    val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                    val apply_n_times :
                      n:Monoid.Int.t ->
                      ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                    val compose :
                      ('-> ('c, 'e) t) ->
                      ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                    val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                    val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                    val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                  end
                module Lift :
                  sig
                    val nullary : '-> ('a, 'e) t
                    val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                    val binary :
                      ('-> '-> 'c) ->
                      ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) t ->
                      ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) t ->
                      ('b, 's) t ->
                      ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                      f:(Monoid.Unit.t -> ('a, 's) t) ->
                      catch:(exn -> ('a, 's) t) -> ('a, 's) t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : ('a, 'e) M.t t -> ('a t, 'e) M.t
                        val all_ignore :
                          ('a, 'e) M.t t -> (Monoid.Unit.t, 'e) M.t
                        val sequence :
                          (Monoid.Unit.t, 'e) M.t t ->
                          (Monoid.Unit.t, 'e) M.t
                        val map :
                          'a t -> f:('-> ('b, 'e) M.t) -> ('b t, 'e) M.t
                        val iter :
                          'a t ->
                          f:('-> (Monoid.Unit.t, 'e) M.t) ->
                          (Monoid.Unit.t, 'e) M.t
                        val fold :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                        val fold_left :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                        val fold_right :
                          'a t ->
                          f:('-> '-> ('b, 'e) M.t) ->
                          init:'-> ('b, 'e) M.t
                        val reduce :
                          'a t ->
                          f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t
                        val exists :
                          'a t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                        val for_all :
                          'a t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                        val count :
                          'a t ->
                          f:('-> (bool, 'e) M.t) -> (Monoid.Int.t, 'e) M.t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t -> f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t
                        val find :
                          'a t ->
                          f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t
                        val find_map :
                          'a t ->
                          f:('-> ('b option, 'e) M.t) ->
                          ('b option, 'e) M.t
                        val filter :
                          'a t -> f:('-> (bool, 'e) M.t) -> ('a t, 'e) M.t
                        val filter_map :
                          'a t ->
                          f:('-> ('b option, 'e) M.t) -> ('b t, 'e) M.t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                          val all_ignore :
                            ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                          val sequence :
                            (Monoid.Unit.t, 'e) t T.t ->
                            (Monoid.Unit.t, 'e) t
                          val map :
                            'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                          val iter :
                            'T.t ->
                            f:('-> (Monoid.Unit.t, 'e) t) ->
                            (Monoid.Unit.t, 'e) t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) t) ->
                            init:'-> ('b, 'e) t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                          val exists :
                            'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val for_all :
                            'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) t) -> ('a option, 'e) t
                          val find_map :
                            'T.t ->
                            f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                          val filter_map :
                            'T.t ->
                            f:('-> ('b option, 'e) t) -> ('T.t, 'e) t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                          val all_ignore :
                            ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                          val sequence :
                            (Monoid.Unit.t, 'e) t T.t ->
                            (Monoid.Unit.t, 'e) t
                          val map :
                            'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                          val iter :
                            'T.t ->
                            f:('-> (Monoid.Unit.t, 'e) t) ->
                            (Monoid.Unit.t, 'e) t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) t) ->
                            init:'-> ('b, 'e) t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                          val exists :
                            'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val for_all :
                            'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) t) -> ('a option, 'e) t
                          val find_map :
                            'T.t ->
                            f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                          val filter_map :
                            'T.t ->
                            f:('-> ('b option, 'e) t) -> ('T.t, 'e) t
                        end
                  end
                module List :
                  sig
                    val all : ('a, 'e) t list -> ('a list, 'e) t
                    val all_ignore : ('a, 'e) t list -> (Monoid.Unit.t, 'e) t
                    val sequence :
                      (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                    val map :
                      'a list -> f:('-> ('b, 'e) t) -> ('b list, 'e) t
                    val iter :
                      'a list ->
                      f:('-> (Monoid.Unit.t, 'e) t) ->
                      (Monoid.Unit.t, 'e) t
                    val fold :
                      'a list ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'a list ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'a list ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'a list ->
                      f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                    val exists :
                      'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'a list ->
                      f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b list -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'a list -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
                    val find_map :
                      'a list ->
                      f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                    val filter :
                      'a list -> f:('-> (bool, 'e) t) -> ('a list, 'e) t
                    val filter_map :
                      'a list ->
                      f:('-> ('b option, 'e) t) -> ('b list, 'e) t
                  end
                module Seq :
                  sig
                    val all :
                      ('a, 'e) t Core_kernel.Std.Sequence.t ->
                      ('Core_kernel.Std.Sequence.t, 'e) t
                    val all_ignore :
                      ('a, 'e) t Core_kernel.Std.Sequence.t ->
                      (Monoid.Unit.t, 'e) t
                    val sequence :
                      (Monoid.Unit.t, 'e) t Core_kernel.Std.Sequence.t ->
                      (Monoid.Unit.t, 'e) t
                    val map :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> ('b, 'e) t) ->
                      ('Core_kernel.Std.Sequence.t, 'e) t
                    val iter :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> (Monoid.Unit.t, 'e) t) ->
                      (Monoid.Unit.t, 'e) t
                    val fold :
                      'Core_kernel.Std.Sequence.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'Core_kernel.Std.Sequence.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                    val exists :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> (bool, 'e) t) -> ('a option, 'e) t
                    val find_map :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                    val filter :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> (bool, 'e) t) ->
                      ('Core_kernel.Std.Sequence.t, 'e) t
                    val filter_map :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> ('b option, 'e) t) ->
                      ('Core_kernel.Std.Sequence.t, 'e) t
                  end
                val ( >=> ) :
                  ('-> ('b, 'e) t) ->
                  ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                val ( !! ) : '-> ('a, 'e) t
                val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                val ( !$$ ) :
                  ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) t ->
                  ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) t ->
                  ('b, 's) t ->
                  ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) t
                    val ( >>= ) :
                      ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                    val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) t
                        val bind :
                          ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                        val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                        val both :
                          ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                    val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  end
                val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                val return : '-> ('a, 'b) t
                val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                val all : ('a, 'e) t list -> ('a list, 'e) t
                val all_ignore :
                  (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                module Syntax :
                  sig
                    val ( >>= ) :
                      ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                    val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                    val ( >=> ) :
                      ('-> ('b, 'e) t) ->
                      ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                    val ( !! ) : '-> ('a, 'e) t
                    val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) t ->
                      ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) t ->
                      ('b, 's) t ->
                      ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                  end
              end
          module Minimal :
            functor (M : Minimal->
              sig
                type 'a t = 'M.t
                val void : 'a t -> Monoid.Unit.t t
                val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
                val forever : 'a t -> 'b t
                module Fn :
                  sig
                    val id : '-> 'a t
                    val ignore : 'a t -> Monoid.Unit.t t
                    val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                    val non : ('-> bool t) -> '-> bool t
                    val apply_n_times :
                      n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                    val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b) t -> 'a t
                    val snd : ('a * 'b) t -> 'b t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c) t -> 'a t
                    val snd : ('a * 'b * 'c) t -> 'b t
                    val trd : ('a * 'b * 'c) t -> 'c t
                  end
                module Lift :
                  sig
                    val nullary : '-> 'a t
                    val unary : ('-> 'b) -> 'a t -> 'b t
                    val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                    val ternary :
                      ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      'a t -> 'b t -> 'c t -> 'd t -> 'e t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                      f:(Monoid.Unit.t -> 'a t) ->
                      catch:(exn -> 'a t) -> 'a t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : 'M.t t -> 'a t M.t
                        val all_ignore : 'M.t t -> Monoid.Unit.t M.t
                        val sequence :
                          Monoid.Unit.t M.t t -> Monoid.Unit.t M.t
                        val map : 'a t -> f:('-> 'M.t) -> 'b t M.t
                        val iter :
                          'a t ->
                          f:('-> Monoid.Unit.t M.t) -> Monoid.Unit.t M.t
                        val fold :
                          'a t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                        val fold_left :
                          'a t -> init:'-> f:('-> '-> 'M.t) -> 'M.t
                        val fold_right :
                          'a t -> f:('-> '-> 'M.t) -> init:'-> 'M.t
                        val reduce :
                          'a t -> f:('-> '-> 'M.t) -> 'a option M.t
                        val exists : 'a t -> f:('-> bool M.t) -> bool M.t
                        val for_all : 'a t -> f:('-> bool M.t) -> bool M.t
                        val count :
                          'a t -> f:('-> bool M.t) -> Monoid.Int.t M.t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t -> f:('-> 'M.t) -> 'M.t
                        val find :
                          'a t -> f:('-> bool M.t) -> 'a option M.t
                        val find_map :
                          'a t -> f:('-> 'b option M.t) -> 'b option M.t
                        val filter : 'a t -> f:('-> bool M.t) -> 'a t M.t
                        val filter_map :
                          'a t -> f:('-> 'b option M.t) -> 'b t M.t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all : 'a t T.t -> 'T.t t
                          val all_ignore : 'a t T.t -> Monoid.Unit.t t
                          val sequence :
                            Monoid.Unit.t t T.t -> Monoid.Unit.t t
                          val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                          val fold :
                            'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_left :
                            'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_right :
                            'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                          val reduce :
                            'T.t -> f:('-> '-> 'a t) -> 'a option t
                          val exists : 'T.t -> f:('-> bool t) -> bool t
                          val for_all : 'T.t -> f:('-> bool t) -> bool t
                          val count :
                            'T.t -> f:('-> bool t) -> Monoid.Int.t t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> 'a t) -> 'a t
                          val find :
                            'T.t -> f:('-> bool t) -> 'a option t
                          val find_map :
                            'T.t -> f:('-> 'b option t) -> 'b option t
                          val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                          val filter_map :
                            'T.t -> f:('-> 'b option t) -> 'T.t t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all : 'a t T.t -> 'T.t t
                          val all_ignore : 'a t T.t -> Monoid.Unit.t t
                          val sequence :
                            Monoid.Unit.t t T.t -> Monoid.Unit.t t
                          val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                          val iter :
                            'T.t ->
                            f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                          val fold :
                            'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_left :
                            'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_right :
                            'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                          val reduce :
                            'T.t -> f:('-> '-> 'a t) -> 'a option t
                          val exists : 'T.t -> f:('-> bool t) -> bool t
                          val for_all : 'T.t -> f:('-> bool t) -> bool t
                          val count :
                            'T.t -> f:('-> bool t) -> Monoid.Int.t t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> 'a t) -> 'a t
                          val find :
                            'T.t -> f:('-> bool t) -> 'a option t
                          val find_map :
                            'T.t -> f:('-> 'b option t) -> 'b option t
                          val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                          val filter_map :
                            'T.t -> f:('-> 'b option t) -> 'T.t t
                        end
                  end
                module List :
                  sig
                    val all : 'a t list -> 'a list t
                    val all_ignore : 'a t list -> Monoid.Unit.t t
                    val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
                    val map : 'a list -> f:('-> 'b t) -> 'b list t
                    val iter :
                      'a list -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                    val fold :
                      'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'a list -> f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'a list -> f:('-> '-> 'a t) -> 'a option t
                    val exists : 'a list -> f:('-> bool t) -> bool t
                    val for_all : 'a list -> f:('-> bool t) -> bool t
                    val count : 'a list -> f:('-> bool t) -> Monoid.Int.t t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b list -> f:('-> 'a t) -> 'a t
                    val find : 'a list -> f:('-> bool t) -> 'a option t
                    val find_map :
                      'a list -> f:('-> 'b option t) -> 'b option t
                    val filter : 'a list -> f:('-> bool t) -> 'a list t
                    val filter_map :
                      'a list -> f:('-> 'b option t) -> 'b list t
                  end
                module Seq :
                  sig
                    val all :
                      'a t Core_kernel.Std.Sequence.t ->
                      'Core_kernel.Std.Sequence.t t
                    val all_ignore :
                      'a t Core_kernel.Std.Sequence.t -> Monoid.Unit.t t
                    val sequence :
                      Monoid.Unit.t t Core_kernel.Std.Sequence.t ->
                      Monoid.Unit.t t
                    val map :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> 'b t) -> 'Core_kernel.Std.Sequence.t t
                    val iter :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                    val fold :
                      'Core_kernel.Std.Sequence.t ->
                      init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_left :
                      'Core_kernel.Std.Sequence.t ->
                      init:'-> f:('-> '-> 'b t) -> 'b t
                    val fold_right :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> '-> 'b t) -> init:'-> 'b t
                    val reduce :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> '-> 'a t) -> 'a option t
                    val exists :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool t) -> bool t
                    val for_all :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool t) -> bool t
                    val count :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool t) -> Monoid.Int.t t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Core_kernel.Std.Sequence.t -> f:('-> 'a t) -> 'a t
                    val find :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool t) -> 'a option t
                    val find_map :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> 'b option t) -> 'b option t
                    val filter :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> bool t) -> 'Core_kernel.Std.Sequence.t t
                    val filter_map :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> 'b option t) ->
                      'Core_kernel.Std.Sequence.t t
                  end
                val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                val ( !! ) : '-> 'a t
                val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  'a t -> 'b t -> 'c t -> 'd t -> 'e t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                module Monad_infix :
                  sig
                    val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                    val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  end
                val bind : 'a t -> f:('-> 'b t) -> 'b t
                val return : '-> 'a t
                val map : 'a t -> f:('-> 'b) -> 'b t
                val join : 'a t t -> 'a t
                val ignore_m : 'a t -> Monoid.Unit.t t
                val all : 'a t list -> 'a list t
                val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
                module Let_syntax :
                  sig
                    val return : '-> 'a t
                    val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                    val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                    module Let_syntax :
                      sig
                        val return : '-> 'a t
                        val bind : 'a t -> f:('-> 'b t) -> 'b t
                        val map : 'a t -> f:('-> 'b) -> 'b t
                        val both : 'a t -> 'b t -> ('a * 'b) t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Syntax :
                  sig
                    val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                    val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                    val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                    val ( !! ) : '-> 'a t
                    val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                    val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'a t -> 'b t -> 'c t -> 'd t -> 'e t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                  end
              end
          module Minimal2 :
            functor (M : Minimal2->
              sig
                type ('a, 'e) t = ('a, 'e) M.t
                val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                val sequence :
                  (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                val forever : ('a, 'e) t -> ('b, 'e) t
                module Fn :
                  sig
                    val id : '-> ('a, 'e) t
                    val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                    val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                    val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                    val apply_n_times :
                      n:Monoid.Int.t ->
                      ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                    val compose :
                      ('-> ('c, 'e) t) ->
                      ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                  end
                module Pair :
                  sig
                    val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                    val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                  end
                module Triple :
                  sig
                    val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                    val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                    val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                  end
                module Lift :
                  sig
                    val nullary : '-> ('a, 'e) t
                    val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                    val binary :
                      ('-> '-> 'c) ->
                      ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                    val ternary :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                    val quaternary :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) t ->
                      ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                    val quinary :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) t ->
                      ('b, 's) t ->
                      ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                  end
                module Exn :
                  sig
                    val expect :
                      ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                      f:(Monoid.Unit.t -> ('a, 's) t) ->
                      catch:(exn -> ('a, 's) t) -> ('a, 's) t
                  end
                module Collection :
                  sig
                    module type S =
                      sig
                        type 'a t
                        val all : ('a, 'e) M.t t -> ('a t, 'e) M.t
                        val all_ignore :
                          ('a, 'e) M.t t -> (Monoid.Unit.t, 'e) M.t
                        val sequence :
                          (Monoid.Unit.t, 'e) M.t t ->
                          (Monoid.Unit.t, 'e) M.t
                        val map :
                          'a t -> f:('-> ('b, 'e) M.t) -> ('b t, 'e) M.t
                        val iter :
                          'a t ->
                          f:('-> (Monoid.Unit.t, 'e) M.t) ->
                          (Monoid.Unit.t, 'e) M.t
                        val fold :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                        val fold_left :
                          'a t ->
                          init:'->
                          f:('-> '-> ('b, 'e) M.t) -> ('b, 'e) M.t
                        val fold_right :
                          'a t ->
                          f:('-> '-> ('b, 'e) M.t) ->
                          init:'-> ('b, 'e) M.t
                        val reduce :
                          'a t ->
                          f:('-> '-> ('a, 'e) M.t) -> ('a option, 'e) M.t
                        val exists :
                          'a t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                        val for_all :
                          'a t -> f:('-> (bool, 'e) M.t) -> (bool, 'e) M.t
                        val count :
                          'a t ->
                          f:('-> (bool, 'e) M.t) -> (Monoid.Int.t, 'e) M.t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b t -> f:('-> ('a, 'e) M.t) -> ('a, 'e) M.t
                        val find :
                          'a t ->
                          f:('-> (bool, 'e) M.t) -> ('a option, 'e) M.t
                        val find_map :
                          'a t ->
                          f:('-> ('b option, 'e) M.t) ->
                          ('b option, 'e) M.t
                        val filter :
                          'a t -> f:('-> (bool, 'e) M.t) -> ('a t, 'e) M.t
                        val filter_map :
                          'a t ->
                          f:('-> ('b option, 'e) M.t) -> ('b t, 'e) M.t
                      end
                    module Eager :
                      functor (T : Collection.Eager->
                        sig
                          val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                          val all_ignore :
                            ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                          val sequence :
                            (Monoid.Unit.t, 'e) t T.t ->
                            (Monoid.Unit.t, 'e) t
                          val map :
                            'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                          val iter :
                            'T.t ->
                            f:('-> (Monoid.Unit.t, 'e) t) ->
                            (Monoid.Unit.t, 'e) t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) t) ->
                            init:'-> ('b, 'e) t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                          val exists :
                            'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val for_all :
                            'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) t) -> ('a option, 'e) t
                          val find_map :
                            'T.t ->
                            f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                          val filter_map :
                            'T.t ->
                            f:('-> ('b option, 'e) t) -> ('T.t, 'e) t
                        end
                    module Delay :
                      functor (T : Collection.Delay->
                        sig
                          val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                          val all_ignore :
                            ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                          val sequence :
                            (Monoid.Unit.t, 'e) t T.t ->
                            (Monoid.Unit.t, 'e) t
                          val map :
                            'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                          val iter :
                            'T.t ->
                            f:('-> (Monoid.Unit.t, 'e) t) ->
                            (Monoid.Unit.t, 'e) t
                          val fold :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_left :
                            'T.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_right :
                            'T.t ->
                            f:('-> '-> ('b, 'e) t) ->
                            init:'-> ('b, 'e) t
                          val reduce :
                            'T.t ->
                            f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                          val exists :
                            'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val for_all :
                            'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val count :
                            'T.t ->
                            f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                          val find :
                            'T.t ->
                            f:('-> (bool, 'e) t) -> ('a option, 'e) t
                          val find_map :
                            'T.t ->
                            f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                          val filter :
                            'T.t ->
                            f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                          val filter_map :
                            'T.t ->
                            f:('-> ('b option, 'e) t) -> ('T.t, 'e) t
                        end
                  end
                module List :
                  sig
                    val all : ('a, 'e) t list -> ('a list, 'e) t
                    val all_ignore : ('a, 'e) t list -> (Monoid.Unit.t, 'e) t
                    val sequence :
                      (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                    val map :
                      'a list -> f:('-> ('b, 'e) t) -> ('b list, 'e) t
                    val iter :
                      'a list ->
                      f:('-> (Monoid.Unit.t, 'e) t) ->
                      (Monoid.Unit.t, 'e) t
                    val fold :
                      'a list ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'a list ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'a list ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'a list ->
                      f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                    val exists :
                      'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'a list ->
                      f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'b list -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'a list -> f:('-> (bool, 'e) t) -> ('a option, 'e) t
                    val find_map :
                      'a list ->
                      f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                    val filter :
                      'a list -> f:('-> (bool, 'e) t) -> ('a list, 'e) t
                    val filter_map :
                      'a list ->
                      f:('-> ('b option, 'e) t) -> ('b list, 'e) t
                  end
                module Seq :
                  sig
                    val all :
                      ('a, 'e) t Core_kernel.Std.Sequence.t ->
                      ('Core_kernel.Std.Sequence.t, 'e) t
                    val all_ignore :
                      ('a, 'e) t Core_kernel.Std.Sequence.t ->
                      (Monoid.Unit.t, 'e) t
                    val sequence :
                      (Monoid.Unit.t, 'e) t Core_kernel.Std.Sequence.t ->
                      (Monoid.Unit.t, 'e) t
                    val map :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> ('b, 'e) t) ->
                      ('Core_kernel.Std.Sequence.t, 'e) t
                    val iter :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> (Monoid.Unit.t, 'e) t) ->
                      (Monoid.Unit.t, 'e) t
                    val fold :
                      'Core_kernel.Std.Sequence.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_left :
                      'Core_kernel.Std.Sequence.t ->
                      init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                    val fold_right :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                    val reduce :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                    val exists :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val for_all :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> (bool, 'e) t) -> (bool, 'e) t
                    val count :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                    val map_reduce :
                      (module Monoid.S with type t = 'a) ->
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> ('a, 'e) t) -> ('a, 'e) t
                    val find :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> (bool, 'e) t) -> ('a option, 'e) t
                    val find_map :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                    val filter :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> (bool, 'e) t) ->
                      ('Core_kernel.Std.Sequence.t, 'e) t
                    val filter_map :
                      'Core_kernel.Std.Sequence.t ->
                      f:('-> ('b option, 'e) t) ->
                      ('Core_kernel.Std.Sequence.t, 'e) t
                  end
                val ( >=> ) :
                  ('-> ('b, 'e) t) ->
                  ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                val ( !! ) : '-> ('a, 'e) t
                val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                val ( !$$ ) :
                  ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                val ( !$$$ ) :
                  ('-> '-> '-> 'd) ->
                  ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                val ( !$$$$ ) :
                  ('-> '-> '-> '-> 'e) ->
                  ('a, 's) t ->
                  ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                val ( !$$$$$ ) :
                  ('-> '-> '-> '-> '-> 'f) ->
                  ('a, 's) t ->
                  ('b, 's) t ->
                  ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) t
                    val ( >>= ) :
                      ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                    val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) t
                        val bind :
                          ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                        val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                        val both :
                          ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                    val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  end
                val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                val return : '-> ('a, 'b) t
                val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                val all : ('a, 'e) t list -> ('a list, 'e) t
                val all_ignore :
                  (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                module Syntax :
                  sig
                    val ( >>= ) :
                      ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                    val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                    val ( >=> ) :
                      ('-> ('b, 'e) t) ->
                      ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                    val ( !! ) : '-> ('a, 'e) t
                    val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) t ->
                      ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) t ->
                      ('b, 's) t ->
                      ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                  end
              end
          module type Monad = S
          module type Monad2 = S2
          module Ident :
            sig
              type 'a t = 'a
              val void : '-> Monoid.Unit.t
              val sequence : Monoid.Unit.t list -> Monoid.Unit.t
              val forever : '-> 'b
              module Fn :
                sig
                  val id : '-> 'a
                  val ignore : '-> Monoid.Unit.t
                  val nothing : Monoid.Unit.t -> Monoid.Unit.t
                  val non : ('-> bool) -> '-> bool
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> 'a) -> '-> 'a
                  val compose : ('-> 'c) -> ('-> 'b) -> '-> 'c
                end
              module Pair :
                sig val fst : 'a * '-> 'val snd : 'a * '-> 'end
              module Triple :
                sig
                  val fst : 'a * 'b * '-> 'a
                  val snd : 'a * 'b * '-> 'b
                  val trd : 'a * 'b * '-> 'c
                end
              module Lift :
                sig
                  val nullary : '-> 'a
                  val unary : ('-> 'b) -> '-> 'b
                  val binary : ('-> '-> 'c) -> '-> '-> 'c
                  val ternary :
                    ('-> '-> '-> 'd) -> '-> '-> '-> 'd
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    '-> '-> '-> '-> 'e
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    '-> '-> '-> '-> '-> 'f
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> Monoid.Unit.t) ->
                    f:(Monoid.Unit.t -> 'a) -> catch:(exn -> 'a) -> 'a
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : 'a t -> 'a t
                      val all_ignore : 'a t -> Monoid.Unit.t
                      val sequence : Monoid.Unit.t t -> Monoid.Unit.t
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val iter :
                        'a t -> f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                      val fold : 'a t -> init:'-> f:('-> '-> 'b) -> 'b
                      val fold_left :
                        'a t -> init:'-> f:('-> '-> 'b) -> 'b
                      val fold_right :
                        'a t -> f:('-> '-> 'b) -> init:'-> 'b
                      val reduce : 'a t -> f:('-> '-> 'a) -> 'a option
                      val exists : 'a t -> f:('-> bool) -> bool
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> Monoid.Int.t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> 'a) -> 'a
                      val find : 'a t -> f:('-> bool) -> 'a option
                      val find_map : 'a t -> f:('-> 'b option) -> 'b option
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : 'T.t -> 'T.t
                        val all_ignore : 'T.t -> Monoid.Unit.t
                        val sequence : Monoid.Unit.t T.t -> Monoid.Unit.t
                        val map : 'T.t -> f:('-> 'b) -> 'T.t
                        val iter :
                          'T.t -> f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b) -> 'b
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b) -> 'b
                        val fold_right :
                          'T.t -> f:('-> '-> 'b) -> init:'-> 'b
                        val reduce :
                          'T.t -> f:('-> '-> 'a) -> 'a option
                        val exists : 'T.t -> f:('-> bool) -> bool
                        val for_all : 'T.t -> f:('-> bool) -> bool
                        val count : 'T.t -> f:('-> bool) -> Monoid.Int.t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a) -> 'a
                        val find : 'T.t -> f:('-> bool) -> 'a option
                        val find_map :
                          'T.t -> f:('-> 'b option) -> 'b option
                        val filter : 'T.t -> f:('-> bool) -> 'T.t
                        val filter_map :
                          'T.t -> f:('-> 'b option) -> 'T.t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : 'T.t -> 'T.t
                        val all_ignore : 'T.t -> Monoid.Unit.t
                        val sequence : Monoid.Unit.t T.t -> Monoid.Unit.t
                        val map : 'T.t -> f:('-> 'b) -> 'T.t
                        val iter :
                          'T.t -> f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b) -> 'b
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b) -> 'b
                        val fold_right :
                          'T.t -> f:('-> '-> 'b) -> init:'-> 'b
                        val reduce :
                          'T.t -> f:('-> '-> 'a) -> 'a option
                        val exists : 'T.t -> f:('-> bool) -> bool
                        val for_all : 'T.t -> f:('-> bool) -> bool
                        val count : 'T.t -> f:('-> bool) -> Monoid.Int.t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a) -> 'a
                        val find : 'T.t -> f:('-> bool) -> 'a option
                        val find_map :
                          'T.t -> f:('-> 'b option) -> 'b option
                        val filter : 'T.t -> f:('-> bool) -> 'T.t
                        val filter_map :
                          'T.t -> f:('-> 'b option) -> 'T.t
                      end
                end
              module List :
                sig
                  val all : 'a list -> 'a list
                  val all_ignore : 'a list -> Monoid.Unit.t
                  val sequence : Monoid.Unit.t list -> Monoid.Unit.t
                  val map : 'a list -> f:('-> 'b) -> 'b list
                  val iter :
                    'a list -> f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                  val fold : 'a list -> init:'-> f:('-> '-> 'b) -> 'b
                  val fold_left :
                    'a list -> init:'-> f:('-> '-> 'b) -> 'b
                  val fold_right :
                    'a list -> f:('-> '-> 'b) -> init:'-> 'b
                  val reduce : 'a list -> f:('-> '-> 'a) -> 'a option
                  val exists : 'a list -> f:('-> bool) -> bool
                  val for_all : 'a list -> f:('-> bool) -> bool
                  val count : 'a list -> f:('-> bool) -> Monoid.Int.t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b list -> f:('-> 'a) -> 'a
                  val find : 'a list -> f:('-> bool) -> 'a option
                  val find_map : 'a list -> f:('-> 'b option) -> 'b option
                  val filter : 'a list -> f:('-> bool) -> 'a list
                  val filter_map : 'a list -> f:('-> 'b option) -> 'b list
                end
              module Seq :
                sig
                  val all :
                    'Core_kernel.Std.Sequence.t ->
                    'Core_kernel.Std.Sequence.t
                  val all_ignore :
                    'Core_kernel.Std.Sequence.t -> Monoid.Unit.t
                  val sequence :
                    Monoid.Unit.t Core_kernel.Std.Sequence.t -> Monoid.Unit.t
                  val map :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> 'b) -> 'Core_kernel.Std.Sequence.t
                  val iter :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                  val fold :
                    'Core_kernel.Std.Sequence.t ->
                    init:'-> f:('-> '-> 'b) -> 'b
                  val fold_left :
                    'Core_kernel.Std.Sequence.t ->
                    init:'-> f:('-> '-> 'b) -> 'b
                  val fold_right :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> '-> 'b) -> init:'-> 'b
                  val reduce :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> '-> 'a) -> 'a option
                  val exists :
                    'Core_kernel.Std.Sequence.t -> f:('-> bool) -> bool
                  val for_all :
                    'Core_kernel.Std.Sequence.t -> f:('-> bool) -> bool
                  val count :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> bool) -> Monoid.Int.t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Core_kernel.Std.Sequence.t -> f:('-> 'a) -> 'a
                  val find :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> bool) -> 'a option
                  val find_map :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> 'b option) -> 'b option
                  val filter :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> bool) -> 'Core_kernel.Std.Sequence.t
                  val filter_map :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> 'b option) -> 'Core_kernel.Std.Sequence.t
                end
              val ( >=> ) : ('-> 'b) -> ('-> 'c) -> '-> 'c
              val ( !! ) : '-> 'a
              val ( !$ ) : ('-> 'b) -> '-> 'b
              val ( !$$ ) : ('-> '-> 'c) -> '-> '-> 'c
              val ( !$$$ ) : ('-> '-> '-> 'd) -> '-> '-> '-> 'd
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) -> '-> '-> '-> '-> 'e
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                '-> '-> '-> '-> '-> 'f
              val ( >>= ) : '-> ('-> 'b) -> 'b
              val ( >>| ) : '-> ('-> 'b) -> 'b
              module Monad_infix :
                sig
                  val ( >>= ) : '-> ('-> 'b) -> 'b
                  val ( >>| ) : '-> ('-> 'b) -> 'b
                end
              val bind : '-> f:('-> 'b) -> 'b
              val return : '-> 'a
              val map : '-> f:('-> 'b) -> 'b
              val join : '-> 'a
              val ignore_m : '-> Monoid.Unit.t
              val all : 'a list -> 'a list
              val all_ignore : Monoid.Unit.t list -> Monoid.Unit.t
              module Let_syntax :
                sig
                  val return : '-> 'a
                  val ( >>= ) : '-> ('-> 'b) -> 'b
                  val ( >>| ) : '-> ('-> 'b) -> 'b
                  module Let_syntax :
                    sig
                      val return : '-> 'a
                      val bind : '-> f:('-> 'b) -> 'b
                      val map : '-> f:('-> 'b) -> 'b
                      val both : '-> '-> 'a * 'b
                      module Open_on_rhs : sig  end
                    end
                end
              module Syntax :
                sig
                  val ( >>= ) : '-> ('-> 'b) -> 'b
                  val ( >>| ) : '-> ('-> 'b) -> 'b
                  val ( >=> ) : ('-> 'b) -> ('-> 'c) -> '-> 'c
                  val ( !! ) : '-> 'a
                  val ( !$ ) : ('-> 'b) -> '-> 'b
                  val ( !$$ ) : ('-> '-> 'c) -> '-> '-> 'c
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> '-> '-> '-> 'd
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    '-> '-> '-> '-> 'e
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    '-> '-> '-> '-> '-> 'f
                end
            end
          module Option :
            sig
              module type S =
                sig
                  type 'a t
                  type 'a m
                  type 'a e
                  val lift : 'a m -> 'a t
                  val run : 'a t -> 'a e
                  val void : 'a t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
                  val forever : 'a t -> 'b t
                  module Fn :
                    sig
                      val id : '-> 'a t
                      val ignore : 'a t -> Monoid.Unit.t t
                      val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                      val non : ('-> bool t) -> '-> bool t
                      val apply_n_times :
                        n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                      val compose :
                        ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                    end
                  module Pair :
                    sig
                      val fst : ('a * 'b) t -> 'a t
                      val snd : ('a * 'b) t -> 'b t
                    end
                  module Triple :
                    sig
                      val fst : ('a * 'b * 'c) t -> 'a t
                      val snd : ('a * 'b * 'c) t -> 'b t
                      val trd : ('a * 'b * 'c) t -> 'c t
                    end
                  module Lift :
                    sig
                      val nullary : '-> 'a t
                      val unary : ('-> 'b) -> 'a t -> 'b t
                      val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ternary :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val quaternary :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val quinary :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                  module Exn :
                    sig
                      val expect :
                        ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                        f:(Monoid.Unit.t -> 'a t) ->
                        catch:(exn -> 'a t) -> 'a t
                    end
                  module Collection :
                    sig
                      module type S =
                        sig
                          type 'a t
                          val all : 'a t t -> 'a t t
                          val all_ignore : 'a t t -> Monoid.Unit.t t
                          val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                          val map : 'a t -> f:('-> 'b t) -> 'b t t
                          val iter :
                            'a t ->
                            f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                          val fold :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_left :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_right :
                            'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                          val reduce :
                            'a t -> f:('-> '-> 'a t) -> 'a option t
                          val exists : 'a t -> f:('-> bool t) -> bool t
                          val for_all : 'a t -> f:('-> bool t) -> bool t
                          val count :
                            'a t -> f:('-> bool t) -> Monoid.Int.t t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b t -> f:('-> 'a t) -> 'a t
                          val find : 'a t -> f:('-> bool t) -> 'a option t
                          val find_map :
                            'a t -> f:('-> 'b option t) -> 'b option t
                          val filter : 'a t -> f:('-> bool t) -> 'a t t
                          val filter_map :
                            'a t -> f:('-> 'b option t) -> 'b t t
                        end
                      module Eager :
                        functor (T : Collection.Eager->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'a option t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'a option t
                            val find_map :
                              'T.t -> f:('-> 'b option t) -> 'b option t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'b option t) -> 'T.t t
                          end
                      module Delay :
                        functor (T : Collection.Delay->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'a option t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'a option t
                            val find_map :
                              'T.t -> f:('-> 'b option t) -> 'b option t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'b option t) -> 'T.t t
                          end
                    end
                  module List :
                    sig
                      val all : 'a t list -> 'a list t
                      val all_ignore : 'a t list -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
                      val map : 'a list -> f:('-> 'b t) -> 'b list t
                      val iter :
                        'a list ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'a list -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'a list -> f:('-> '-> 'a t) -> 'a option t
                      val exists : 'a list -> f:('-> bool t) -> bool t
                      val for_all : 'a list -> f:('-> bool t) -> bool t
                      val count :
                        'a list -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b list -> f:('-> 'a t) -> 'a t
                      val find : 'a list -> f:('-> bool t) -> 'a option t
                      val find_map :
                        'a list -> f:('-> 'b option t) -> 'b option t
                      val filter : 'a list -> f:('-> bool t) -> 'a list t
                      val filter_map :
                        'a list -> f:('-> 'b option t) -> 'b list t
                    end
                  module Seq :
                    sig
                      val all :
                        'a t Core_kernel.Std.Sequence.t ->
                        'Core_kernel.Std.Sequence.t t
                      val all_ignore :
                        'a t Core_kernel.Std.Sequence.t -> Monoid.Unit.t t
                      val sequence :
                        Monoid.Unit.t t Core_kernel.Std.Sequence.t ->
                        Monoid.Unit.t t
                      val map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> 'b t) -> 'Core_kernel.Std.Sequence.t t
                      val iter :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'Core_kernel.Std.Sequence.t ->
                        init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'Core_kernel.Std.Sequence.t ->
                        init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> '-> 'a t) -> 'a option t
                      val exists :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> bool t
                      val for_all :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> bool t
                      val count :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> 'a t) -> 'a t
                      val find :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> 'a option t
                      val find_map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> 'b option t) -> 'b option t
                      val filter :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> 'Core_kernel.Std.Sequence.t t
                      val filter_map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> 'b option t) ->
                        'Core_kernel.Std.Sequence.t t
                    end
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Monad_infix :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                    end
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val return : '-> 'a t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val join : 'a t t -> 'a t
                  val ignore_m : 'a t -> Monoid.Unit.t t
                  val all : 'a t list -> 'a list t
                  val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      module Let_syntax :
                        sig
                          val return : '-> 'a t
                          val bind : 'a t -> f:('-> 'b t) -> 'b t
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val both : 'a t -> 'b t -> ('a * 'b) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Syntax :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      val ( >=> ) :
                        ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                      val ( !! ) : '-> 'a t
                      val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                      val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                  val pure : '-> 'a t
                  val accept : '-> 'a t
                  val reject : Monoid.Unit.t -> 'a t
                  val guard : bool -> Monoid.Unit.t t
                  val on : bool -> Monoid.Unit.t t -> Monoid.Unit.t t
                  val unless : bool -> Monoid.Unit.t t -> Monoid.Unit.t t
                  val zero : Monoid.Unit.t -> 'a t
                  val plus : 'a t -> 'a t -> 'a t
                  type 'a error = Monoid.Unit.t
                  val fail : Monoid.Unit.t -> 'a t
                  val catch : 'a t -> (Monoid.Unit.t -> 'a t) -> 'a t
                end
              module type S2 =
                sig
                  type ('a, 'e) t
                  type ('a, 'e) m
                  type ('a, 'e) e
                  val lift : ('a, 'e) m -> ('a, 'e) t
                  val run : ('a, 'e) t -> ('a, 'e) e
                  val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                  val forever : ('a, 'e) t -> ('b, 'e) t
                  module Fn :
                    sig
                      val id : '-> ('a, 'e) t
                      val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                      val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                      val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                      val apply_n_times :
                        n:Monoid.Int.t ->
                        ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                      val compose :
                        ('-> ('c, 'e) t) ->
                        ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                    end
                  module Pair :
                    sig
                      val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                      val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                    end
                  module Triple :
                    sig
                      val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                      val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                      val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                    end
                  module Lift :
                    sig
                      val nullary : '-> ('a, 'e) t
                      val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                      val binary :
                        ('-> '-> 'c) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                      val ternary :
                        ('-> '-> '-> 'd) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                      val quaternary :
                        ('-> '-> '-> '-> 'e) ->
                        ('a, 's) t ->
                        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                      val quinary :
                        ('-> '-> '-> '-> '-> 'f) ->
                        ('a, 's) t ->
                        ('b, 's) t ->
                        ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                    end
                  module Exn :
                    sig
                      val expect :
                        ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                        f:(Monoid.Unit.t -> ('a, 's) t) ->
                        catch:(exn -> ('a, 's) t) -> ('a, 's) t
                    end
                  module Collection :
                    sig
                      module type S =
                        sig
                          type 'a t
                          val all : ('a, 'e) t t -> ('a t, 'e) t
                          val all_ignore :
                            ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
                          val sequence :
                            (Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
                          val map :
                            'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                          val iter :
                            'a t ->
                            f:('-> (Monoid.Unit.t, 'e) t) ->
                            (Monoid.Unit.t, 'e) t
                          val fold :
                            'a t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_left :
                            'a t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_right :
                            'a t ->
                            f:('-> '-> ('b, 'e) t) ->
                            init:'-> ('b, 'e) t
                          val reduce :
                            'a t ->
                            f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                          val exists :
                            'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val for_all :
                            'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val count :
                            'a t ->
                            f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                          val find :
                            'a t ->
                            f:('-> (bool, 'e) t) -> ('a option, 'e) t
                          val find_map :
                            'a t ->
                            f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                          val filter :
                            'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                          val filter_map :
                            'a t ->
                            f:('-> ('b option, 'e) t) -> ('b t, 'e) t
                        end
                      module Eager :
                        functor (T : Collection.Eager->
                          sig
                            val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                            val all_ignore :
                              ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                            val sequence :
                              (Monoid.Unit.t, 'e) t T.t ->
                              (Monoid.Unit.t, 'e) t
                            val map :
                              'T.t ->
                              f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                            val iter :
                              'T.t ->
                              f:('-> (Monoid.Unit.t, 'e) t) ->
                              (Monoid.Unit.t, 'e) t
                            val fold :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_left :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> ('b, 'e) t) ->
                              init:'-> ('b, 'e) t
                            val reduce :
                              'T.t ->
                              f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                            val exists :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val for_all :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val count :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                            val find :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('a option, 'e) t
                            val find_map :
                              'T.t ->
                              f:('-> ('b option, 'e) t) ->
                              ('b option, 'e) t
                            val filter :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                            val filter_map :
                              'T.t ->
                              f:('-> ('b option, 'e) t) -> ('T.t, 'e) t
                          end
                      module Delay :
                        functor (T : Collection.Delay->
                          sig
                            val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                            val all_ignore :
                              ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                            val sequence :
                              (Monoid.Unit.t, 'e) t T.t ->
                              (Monoid.Unit.t, 'e) t
                            val map :
                              'T.t ->
                              f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                            val iter :
                              'T.t ->
                              f:('-> (Monoid.Unit.t, 'e) t) ->
                              (Monoid.Unit.t, 'e) t
                            val fold :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_left :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> ('b, 'e) t) ->
                              init:'-> ('b, 'e) t
                            val reduce :
                              'T.t ->
                              f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                            val exists :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val for_all :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val count :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                            val find :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('a option, 'e) t
                            val find_map :
                              'T.t ->
                              f:('-> ('b option, 'e) t) ->
                              ('b option, 'e) t
                            val filter :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                            val filter_map :
                              'T.t ->
                              f:('-> ('b option, 'e) t) -> ('T.t, 'e) t
                          end
                    end
                  module List :
                    sig
                      val all : ('a, 'e) t list -> ('a list, 'e) t
                      val all_ignore :
                        ('a, 'e) t list -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                      val map :
                        'a list -> f:('-> ('b, 'e) t) -> ('b list, 'e) t
                      val iter :
                        'a list ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'a list ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'a list ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'a list ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'a list ->
                        f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                      val exists :
                        'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'a list ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b list -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'a list ->
                        f:('-> (bool, 'e) t) -> ('a option, 'e) t
                      val find_map :
                        'a list ->
                        f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                      val filter :
                        'a list -> f:('-> (bool, 'e) t) -> ('a list, 'e) t
                      val filter_map :
                        'a list ->
                        f:('-> ('b option, 'e) t) -> ('b list, 'e) t
                    end
                  module Seq :
                    sig
                      val all :
                        ('a, 'e) t Core_kernel.Std.Sequence.t ->
                        ('Core_kernel.Std.Sequence.t, 'e) t
                      val all_ignore :
                        ('a, 'e) t Core_kernel.Std.Sequence.t ->
                        (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t Core_kernel.Std.Sequence.t ->
                        (Monoid.Unit.t, 'e) t
                      val map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> ('b, 'e) t) ->
                        ('Core_kernel.Std.Sequence.t, 'e) t
                      val iter :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'Core_kernel.Std.Sequence.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'Core_kernel.Std.Sequence.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> '-> ('a, 'e) t) -> ('a option, 'e) t
                      val exists :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> (bool, 'e) t) -> ('a option, 'e) t
                      val find_map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> ('b option, 'e) t) -> ('b option, 'e) t
                      val filter :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> (bool, 'e) t) ->
                        ('Core_kernel.Std.Sequence.t, 'e) t
                      val filter_map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> ('b option, 'e) t) ->
                        ('Core_kernel.Std.Sequence.t, 'e) t
                    end
                  val ( >=> ) :
                    ('-> ('b, 'e) t) ->
                    ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                  val ( !! ) : '-> ('a, 'e) t
                  val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      module Let_syntax :
                        sig
                          val return : '-> ('a, 'b) t
                          val bind :
                            ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                          val both :
                            ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Monad_infix :
                    sig
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                    end
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val return : '-> ('a, 'b) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                  val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val all : ('a, 'e) t list -> ('a list, 'e) t
                  val all_ignore :
                    (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                  module Syntax :
                    sig
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      val ( >=> ) :
                        ('-> ('b, 'e) t) ->
                        ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                      val ( !! ) : '-> ('a, 'e) t
                      val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                      val ( !$$ ) :
                        ('-> '-> 'c) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        ('a, 's) t ->
                        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        ('a, 's) t ->
                        ('b, 's) t ->
                        ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                    end
                  val pure : '-> ('a, 'e) t
                  val accept : '-> ('a, 'e) t
                  val reject : Monoid.Unit.t -> ('a, 'e) t
                  val guard : bool -> (Monoid.Unit.t, 'e) t
                  val on :
                    bool -> (Monoid.Unit.t, 'e) t -> (Monoid.Unit.t, 'e) t
                  val unless :
                    bool -> (Monoid.Unit.t, 'e) t -> (Monoid.Unit.t, 'e) t
                  val zero : Monoid.Unit.t -> ('a, 'e) t
                  val plus : ('a, 'e) t -> ('a, 'e) t -> ('a, 'e) t
                  type 'a error = Monoid.Unit.t
                  val fail : Monoid.Unit.t -> ('a, 'e) t
                  val catch :
                    ('a, 'e) t -> (Monoid.Unit.t -> ('a, 'e) t) -> ('a, 'e) t
                end
              type 'a t = 'a option
              type 'a m = 'a
              type 'a e = 'a t
              val lift : '-> 'a e
              val run : 'a e -> 'a e
              val void : 'a e -> Monoid.Unit.t e
              val sequence : Monoid.Unit.t e list -> Monoid.Unit.t e
              val forever : 'a e -> 'b e
              module Fn :
                sig
                  val id : '-> 'a e
                  val ignore : 'a e -> Monoid.Unit.t e
                  val nothing : Monoid.Unit.t -> Monoid.Unit.t e
                  val non : ('-> bool e) -> '-> bool e
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> 'a e) -> '-> 'a e
                  val compose : ('-> 'c e) -> ('-> 'b e) -> '-> 'c e
                end
              module Pair :
                sig
                  val fst : ('a * 'b) e -> 'a e
                  val snd : ('a * 'b) e -> 'b e
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c) e -> 'a e
                  val snd : ('a * 'b * 'c) e -> 'b e
                  val trd : ('a * 'b * 'c) e -> 'c e
                end
              module Lift :
                sig
                  val nullary : '-> 'a e
                  val unary : ('-> 'b) -> 'a e -> 'b e
                  val binary : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
                  val ternary :
                    ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    'a e -> 'b e -> 'c e -> 'd e -> 'e e
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> Monoid.Unit.t e) ->
                    f:(Monoid.Unit.t -> 'a e) -> catch:(exn -> 'a e) -> 'a e
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : 'a e t -> 'a t e
                      val all_ignore : 'a e t -> Monoid.Unit.t e
                      val sequence : Monoid.Unit.t e t -> Monoid.Unit.t e
                      val map : 'a t -> f:('-> 'b e) -> 'b t e
                      val iter :
                        'a t -> f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                      val fold :
                        'a t -> init:'-> f:('-> '-> 'b e) -> 'b e
                      val fold_left :
                        'a t -> init:'-> f:('-> '-> 'b e) -> 'b e
                      val fold_right :
                        'a t -> f:('-> '-> 'b e) -> init:'-> 'b e
                      val reduce : 'a t -> f:('-> '-> 'a e) -> 'a e e
                      val exists : 'a t -> f:('-> bool e) -> bool e
                      val for_all : 'a t -> f:('-> bool e) -> bool e
                      val count : 'a t -> f:('-> bool e) -> Monoid.Int.t e
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> 'a e) -> 'a e
                      val find : 'a t -> f:('-> bool e) -> 'a e e
                      val find_map : 'a t -> f:('-> 'b e e) -> 'b e e
                      val filter : 'a t -> f:('-> bool e) -> 'a t e
                      val filter_map : 'a t -> f:('-> 'b e e) -> 'b t e
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : 'a e T.t -> 'T.t e
                        val all_ignore : 'a e T.t -> Monoid.Unit.t e
                        val sequence : Monoid.Unit.t e T.t -> Monoid.Unit.t e
                        val map : 'T.t -> f:('-> 'b e) -> 'T.t e
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                        val fold_right :
                          'T.t -> f:('-> '-> 'b e) -> init:'-> 'b e
                        val reduce : 'T.t -> f:('-> '-> 'a e) -> 'a e e
                        val exists : 'T.t -> f:('-> bool e) -> bool e
                        val for_all : 'T.t -> f:('-> bool e) -> bool e
                        val count :
                          'T.t -> f:('-> bool e) -> Monoid.Int.t e
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a e) -> 'a e
                        val find : 'T.t -> f:('-> bool e) -> 'a e e
                        val find_map : 'T.t -> f:('-> 'b e e) -> 'b e e
                        val filter : 'T.t -> f:('-> bool e) -> 'T.t e
                        val filter_map :
                          'T.t -> f:('-> 'b e e) -> 'T.t e
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : 'a e T.t -> 'T.t e
                        val all_ignore : 'a e T.t -> Monoid.Unit.t e
                        val sequence : Monoid.Unit.t e T.t -> Monoid.Unit.t e
                        val map : 'T.t -> f:('-> 'b e) -> 'T.t e
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                        val fold_right :
                          'T.t -> f:('-> '-> 'b e) -> init:'-> 'b e
                        val reduce : 'T.t -> f:('-> '-> 'a e) -> 'a e e
                        val exists : 'T.t -> f:('-> bool e) -> bool e
                        val for_all : 'T.t -> f:('-> bool e) -> bool e
                        val count :
                          'T.t -> f:('-> bool e) -> Monoid.Int.t e
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a e) -> 'a e
                        val find : 'T.t -> f:('-> bool e) -> 'a e e
                        val find_map : 'T.t -> f:('-> 'b e e) -> 'b e e
                        val filter : 'T.t -> f:('-> bool e) -> 'T.t e
                        val filter_map :
                          'T.t -> f:('-> 'b e e) -> 'T.t e
                      end
                end
              module List :
                sig
                  val all : 'a e list -> 'a list e
                  val all_ignore : 'a e list -> Monoid.Unit.t e
                  val sequence : Monoid.Unit.t e list -> Monoid.Unit.t e
                  val map : 'a list -> f:('-> 'b e) -> 'b list e
                  val iter :
                    'a list -> f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                  val fold :
                    'a list -> init:'-> f:('-> '-> 'b e) -> 'b e
                  val fold_left :
                    'a list -> init:'-> f:('-> '-> 'b e) -> 'b e
                  val fold_right :
                    'a list -> f:('-> '-> 'b e) -> init:'-> 'b e
                  val reduce : 'a list -> f:('-> '-> 'a e) -> 'a e e
                  val exists : 'a list -> f:('-> bool e) -> bool e
                  val for_all : 'a list -> f:('-> bool e) -> bool e
                  val count : 'a list -> f:('-> bool e) -> Monoid.Int.t e
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b list -> f:('-> 'a e) -> 'a e
                  val find : 'a list -> f:('-> bool e) -> 'a e e
                  val find_map : 'a list -> f:('-> 'b e e) -> 'b e e
                  val filter : 'a list -> f:('-> bool e) -> 'a list e
                  val filter_map : 'a list -> f:('-> 'b e e) -> 'b list e
                end
              module Seq :
                sig
                  val all :
                    'a e Core_kernel.Std.Sequence.t ->
                    'Core_kernel.Std.Sequence.t e
                  val all_ignore :
                    'a e Core_kernel.Std.Sequence.t -> Monoid.Unit.t e
                  val sequence :
                    Monoid.Unit.t e Core_kernel.Std.Sequence.t ->
                    Monoid.Unit.t e
                  val map :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> 'b e) -> 'Core_kernel.Std.Sequence.t e
                  val iter :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                  val fold :
                    'Core_kernel.Std.Sequence.t ->
                    init:'-> f:('-> '-> 'b e) -> 'b e
                  val fold_left :
                    'Core_kernel.Std.Sequence.t ->
                    init:'-> f:('-> '-> 'b e) -> 'b e
                  val fold_right :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> '-> 'b e) -> init:'-> 'b e
                  val reduce :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> '-> 'a e) -> 'a e e
                  val exists :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> bool e) -> bool e
                  val for_all :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> bool e) -> bool e
                  val count :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> bool e) -> Monoid.Int.t e
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Core_kernel.Std.Sequence.t -> f:('-> 'a e) -> 'a e
                  val find :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> bool e) -> 'a e e
                  val find_map :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> 'b e e) -> 'b e e
                  val filter :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> bool e) -> 'Core_kernel.Std.Sequence.t e
                  val filter_map :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> 'b e e) -> 'Core_kernel.Std.Sequence.t e
                end
              val ( >=> ) : ('-> 'b e) -> ('-> 'c e) -> '-> 'c e
              val ( !! ) : '-> 'a e
              val ( !$ ) : ('-> 'b) -> 'a e -> 'b e
              val ( !$$ ) : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a e -> 'b e -> 'c e -> 'd e -> 'e e
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
              val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
              val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
              module Monad_infix :
                sig
                  val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
                  val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
                end
              val bind : 'a e -> f:('-> 'b e) -> 'b e
              val return : '-> 'a e
              val map : 'a e -> f:('-> 'b) -> 'b e
              val join : 'a e e -> 'a e
              val ignore_m : 'a e -> Monoid.Unit.t e
              val all : 'a e list -> 'a list e
              val all_ignore : Monoid.Unit.t e list -> Monoid.Unit.t e
              module Let_syntax :
                sig
                  val return : '-> 'a e
                  val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
                  val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
                  module Let_syntax :
                    sig
                      val return : '-> 'a e
                      val bind : 'a e -> f:('-> 'b e) -> 'b e
                      val map : 'a e -> f:('-> 'b) -> 'b e
                      val both : 'a e -> 'b e -> ('a * 'b) e
                      module Open_on_rhs : sig  end
                    end
                end
              module Syntax :
                sig
                  val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
                  val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
                  val ( >=> ) : ('-> 'b e) -> ('-> 'c e) -> '-> 'c e
                  val ( !! ) : '-> 'a e
                  val ( !$ ) : ('-> 'b) -> 'a e -> 'b e
                  val ( !$$ ) : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a e -> 'b e -> 'c e -> 'd e -> 'e e
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
                end
              val pure : '-> 'a e
              val accept : '-> 'a e
              val reject : Monoid.Unit.t -> 'a e
              val guard : bool -> Monoid.Unit.t e
              val on : bool -> Monoid.Unit.t e -> Monoid.Unit.t e
              val unless : bool -> Monoid.Unit.t e -> Monoid.Unit.t e
              val zero : Monoid.Unit.t -> 'a e
              val plus : 'a e -> 'a e -> 'a e
              type 'a error = Monoid.Unit.t
              val fail : Monoid.Unit.t -> 'a e
              val catch : 'a e -> (Monoid.Unit.t -> 'a e) -> 'a e
              module T1 :
                functor (M : Core_kernel.Std.T1->
                  sig
                    type 'a t = 'a e M.t
                    type 'a m = 'M.t
                    type 'a e = 'Monads.Std.Monad.Option.T1.t
                  end
              module T2 :
                functor (M : Core_kernel.Std.T2->
                  sig
                    type ('a, 'e) t = ('a e, 'e) M.t
                    type ('a, 'e) m = ('a, 'e) M.t
                    type ('a, 'e) e = ('a, 'e) Monads.Std.Monad.Option.T2.t
                  end
              module Make :
                functor (M : Monad->
                  sig
                    val lift : 'M.t -> 'T1(M).t
                    val run : 'T1(M).t -> 'Monads.Std.Monad.Option.T1.t
                    val void : 'T1(M).t -> Monoid.Unit.t T1(M).t
                    val sequence :
                      Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                    val forever : 'T1(M).t -> 'T1(M).t
                    module Fn :
                      sig
                        val id : '-> 'T1(M).t
                        val ignore : 'T1(M).t -> Monoid.Unit.t T1(M).t
                        val nothing : Monoid.Unit.t -> Monoid.Unit.t T1(M).t
                        val non : ('-> bool T1(M).t) -> '-> bool T1(M).t
                        val apply_n_times :
                          n:Monoid.Int.t ->
                          ('-> 'T1(M).t) -> '-> 'T1(M).t
                        val compose :
                          ('-> 'T1(M).t) ->
                          ('-> 'T1(M).t) -> '-> 'T1(M).t
                      end
                    module Pair :
                      sig
                        val fst : ('a * 'b) T1(M).t -> 'T1(M).t
                        val snd : ('a * 'b) T1(M).t -> 'T1(M).t
                      end
                    module Triple :
                      sig
                        val fst : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                        val snd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                        val trd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                      end
                    module Lift :
                      sig
                        val nullary : '-> 'T1(M).t
                        val unary : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                        val binary :
                          ('-> '-> 'c) ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val ternary :
                          ('-> '-> '-> 'd) ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val quaternary :
                          ('-> '-> '-> '-> 'e) ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val quinary :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                      end
                    module Exn :
                      sig
                        val expect :
                          ?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(M).t) ->
                          f:(Monoid.Unit.t -> 'T1(M).t) ->
                          catch:(exn -> 'T1(M).t) -> 'T1(M).t
                      end
                    module Collection :
                      sig
                        module type S =
                          sig
                            type 'a t
                            val all : 'T1(M).t t -> 'a t T1(M).t
                            val all_ignore :
                              'T1(M).t t -> Monoid.Unit.t T1(M).t
                            val sequence :
                              Monoid.Unit.t T1(M).t t ->
                              Monoid.Unit.t T1(M).t
                            val map :
                              'a t -> f:('-> 'T1(M).t) -> 'b t T1(M).t
                            val iter :
                              'a t ->
                              f:('-> Monoid.Unit.t T1(M).t) ->
                              Monoid.Unit.t T1(M).t
                            val fold :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T1(M).t) -> 'T1(M).t
                            val fold_left :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T1(M).t) -> 'T1(M).t
                            val fold_right :
                              'a t ->
                              f:('-> '-> 'T1(M).t) ->
                              init:'-> 'T1(M).t
                            val reduce :
                              'a t ->
                              f:('-> '-> 'T1(M).t) -> 'a e T1(M).t
                            val exists :
                              'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                            val for_all :
                              'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                            val count :
                              'a t ->
                              f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b t -> f:('-> 'T1(M).t) -> 'T1(M).t
                            val find :
                              'a t -> f:('-> bool T1(M).t) -> 'a e T1(M).t
                            val find_map :
                              'a t -> f:('-> 'b e T1(M).t) -> 'b e T1(M).t
                            val filter :
                              'a t -> f:('-> bool T1(M).t) -> 'a t T1(M).t
                            val filter_map :
                              'a t -> f:('-> 'b e T1(M).t) -> 'b t T1(M).t
                          end
                        module Eager :
                          functor (T : Collection.Eager->
                            sig
                              val all : 'T1(M).t T.t -> 'T.t T1(M).t
                              val all_ignore :
                                'T1(M).t T.t -> Monoid.Unit.t T1(M).t
                              val sequence :
                                Monoid.Unit.t T1(M).t T.t ->
                                Monoid.Unit.t T1(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T1(M).t) -> 'T.t T1(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T1(M).t) ->
                                Monoid.Unit.t T1(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(M).t) -> 'T1(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(M).t) -> 'T1(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T1(M).t) ->
                                init:'-> 'T1(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T1(M).t) -> 'a e T1(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T1(M).t) -> bool T1(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T1(M).t) -> bool T1(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T1(M).t) ->
                                Monoid.Int.t T1(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T1(M).t) -> 'a e T1(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'b e T1(M).t) -> 'b e T1(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T1(M).t) -> 'T.t T1(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'b e T1(M).t) -> 'T.t T1(M).t
                            end
                        module Delay :
                          functor (T : Collection.Delay->
                            sig
                              val all : 'T1(M).t T.t -> 'T.t T1(M).t
                              val all_ignore :
                                'T1(M).t T.t -> Monoid.Unit.t T1(M).t
                              val sequence :
                                Monoid.Unit.t T1(M).t T.t ->
                                Monoid.Unit.t T1(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T1(M).t) -> 'T.t T1(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T1(M).t) ->
                                Monoid.Unit.t T1(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(M).t) -> 'T1(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(M).t) -> 'T1(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T1(M).t) ->
                                init:'-> 'T1(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T1(M).t) -> 'a e T1(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T1(M).t) -> bool T1(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T1(M).t) -> bool T1(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T1(M).t) ->
                                Monoid.Int.t T1(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T1(M).t) -> 'a e T1(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'b e T1(M).t) -> 'b e T1(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T1(M).t) -> 'T.t T1(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'b e T1(M).t) -> 'T.t T1(M).t
                            end
                      end
                    module List :
                      sig
                        val all : 'T1(M).t list -> 'a list T1(M).t
                        val all_ignore :
                          'T1(M).t list -> Monoid.Unit.t T1(M).t
                        val sequence :
                          Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                        val map :
                          'a list -> f:('-> 'T1(M).t) -> 'b list T1(M).t
                        val iter :
                          'a list ->
                          f:('-> Monoid.Unit.t T1(M).t) ->
                          Monoid.Unit.t T1(M).t
                        val fold :
                          'a list ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_left :
                          'a list ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_right :
                          'a list ->
                          f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                        val reduce :
                          'a list ->
                          f:('-> '-> 'T1(M).t) -> 'a e T1(M).t
                        val exists :
                          'a list -> f:('-> bool T1(M).t) -> bool T1(M).t
                        val for_all :
                          'a list -> f:('-> bool T1(M).t) -> bool T1(M).t
                        val count :
                          'a list ->
                          f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b list -> f:('-> 'T1(M).t) -> 'T1(M).t
                        val find :
                          'a list -> f:('-> bool T1(M).t) -> 'a e T1(M).t
                        val find_map :
                          'a list -> f:('-> 'b e T1(M).t) -> 'b e T1(M).t
                        val filter :
                          'a list ->
                          f:('-> bool T1(M).t) -> 'a list T1(M).t
                        val filter_map :
                          'a list ->
                          f:('-> 'b e T1(M).t) -> 'b list T1(M).t
                      end
                    module Seq :
                      sig
                        val all :
                          'T1(M).t Core_kernel.Std.Sequence.t ->
                          'Core_kernel.Std.Sequence.t T1(M).t
                        val all_ignore :
                          'T1(M).t Core_kernel.Std.Sequence.t ->
                          Monoid.Unit.t T1(M).t
                        val sequence :
                          Monoid.Unit.t T1(M).t Core_kernel.Std.Sequence.t ->
                          Monoid.Unit.t T1(M).t
                        val map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'T1(M).t) ->
                          'Core_kernel.Std.Sequence.t T1(M).t
                        val iter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> Monoid.Unit.t T1(M).t) ->
                          Monoid.Unit.t T1(M).t
                        val fold :
                          'Core_kernel.Std.Sequence.t ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_left :
                          'Core_kernel.Std.Sequence.t ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_right :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                        val reduce :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> 'T1(M).t) -> 'a e T1(M).t
                        val exists :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(M).t) -> bool T1(M).t
                        val for_all :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(M).t) -> bool T1(M).t
                        val count :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'T1(M).t) -> 'T1(M).t
                        val find :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(M).t) -> 'a e T1(M).t
                        val find_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'b e T1(M).t) -> 'b e T1(M).t
                        val filter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(M).t) ->
                          'Core_kernel.Std.Sequence.t T1(M).t
                        val filter_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'b e T1(M).t) ->
                          'Core_kernel.Std.Sequence.t T1(M).t
                      end
                    val ( >=> ) :
                      ('-> 'T1(M).t) ->
                      ('-> 'T1(M).t) -> '-> 'T1(M).t
                    val ( !! ) : '-> 'T1(M).t
                    val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(M).t ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( >>= ) :
                      'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                    val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                        val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                      end
                    val bind :
                      'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
                    val return : '-> 'T1(M).t
                    val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                    val join : 'T1(M).t T1(M).t -> 'T1(M).t
                    val ignore_m : 'T1(M).t -> Monoid.Unit.t T1(M).t
                    val all : 'T1(M).t list -> 'a list T1(M).t
                    val all_ignore :
                      Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T1(M).t
                        val ( >>= ) :
                          'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                        val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                        module Let_syntax :
                          sig
                            val return : '-> 'T1(M).t
                            val bind :
                              'T1(M).t ->
                              f:('-> 'T1(M).t) -> 'T1(M).t
                            val map :
                              'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                            val both :
                              'T1(M).t -> 'T1(M).t -> ('a * 'b) T1(M).t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Syntax :
                      sig
                        val ( >>= ) :
                          'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                        val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                        val ( >=> ) :
                          ('-> 'T1(M).t) ->
                          ('-> 'T1(M).t) -> '-> 'T1(M).t
                        val ( !! ) : '-> 'T1(M).t
                        val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                      end
                    val pure : '-> 'T1(M).t
                    val accept : '-> 'T1(M).t
                    val reject : Monoid.Unit.t -> 'T1(M).t
                    val guard : bool -> Monoid.Unit.t T1(M).t
                    val on :
                      bool -> Monoid.Unit.t T1(M).t -> Monoid.Unit.t T1(M).t
                    val unless :
                      bool -> Monoid.Unit.t T1(M).t -> Monoid.Unit.t T1(M).t
                    val zero : Monoid.Unit.t -> 'T1(M).t
                    val plus : 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    type 'a error = Monoid.Unit.t
                    val fail : Monoid.Unit.t -> 'T1(M).t
                    val catch :
                      'T1(M).t ->
                      (Monoid.Unit.t -> 'T1(M).t) -> 'T1(M).t
                  end
              module Make2 :
                functor (M : Monad2->
                  sig
                    val lift : ('a, 'e) M.t -> ('a, 'e) T2(M).t
                    val run :
                      ('a, 'e) T2(M).t ->
                      ('a, 'e) Monads.Std.Monad.Option.T2.t
                    val void :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    module Fn :
                      sig
                        val id : '-> ('a, 'e) T2(M).t
                        val ignore :
                          ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                        val nothing :
                          Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
                        val non :
                          ('-> (bool, 'e) T2(M).t) ->
                          '-> (bool, 'e) T2(M).t
                        val apply_n_times :
                          n:Monoid.Int.t ->
                          ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                        val compose :
                          ('-> ('c, 'e) T2(M).t) ->
                          ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                      end
                    module Pair :
                      sig
                        val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                        val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
                      end
                    module Triple :
                      sig
                        val fst :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                        val snd :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val trd :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
                      end
                    module Lift :
                      sig
                        val nullary : '-> ('a, 'e) T2(M).t
                        val unary :
                          ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val binary :
                          ('-> '-> 'c) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                        val ternary :
                          ('-> '-> '-> 'd) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t ->
                          ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                        val quaternary :
                          ('-> '-> '-> '-> 'e) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                        val quinary :
                          ('-> '-> '-> '-> '-> 'f) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t ->
                          ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                      end
                    module Exn :
                      sig
                        val expect :
                          ?finally:(Monoid.Unit.t ->
                                    (Monoid.Unit.t, 's) T2(M).t) ->
                          f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
                          catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
                      end
                    module Collection :
                      sig
                        module type S =
                          sig
                            type 'a t
                            val all :
                              ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                            val all_ignore :
                              ('a, 'e) T2(M).t t ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val sequence :
                              (Monoid.Unit.t, 'e) T2(M).t t ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val map :
                              'a t ->
                              f:('-> ('b, 'e) T2(M).t) ->
                              ('b t, 'e) T2(M).t
                            val iter :
                              'a t ->
                              f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val fold :
                              'a t ->
                              init:'->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              ('b, 'e) T2(M).t
                            val fold_left :
                              'a t ->
                              init:'->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              ('b, 'e) T2(M).t
                            val fold_right :
                              'a t ->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              init:'-> ('b, 'e) T2(M).t
                            val reduce :
                              'a t ->
                              f:('-> '-> ('a, 'e) T2(M).t) ->
                              ('a e, 'e) T2(M).t
                            val exists :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (bool, 'e) T2(M).t
                            val for_all :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (bool, 'e) T2(M).t
                            val count :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (Monoid.Int.t, 'e) T2(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b t ->
                              f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                            val find :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              ('a e, 'e) T2(M).t
                            val find_map :
                              'a t ->
                              f:('-> ('b e, 'e) T2(M).t) ->
                              ('b e, 'e) T2(M).t
                            val filter :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              ('a t, 'e) T2(M).t
                            val filter_map :
                              'a t ->
                              f:('-> ('b e, 'e) T2(M).t) ->
                              ('b t, 'e) T2(M).t
                          end
                        module Eager :
                          functor (T : Collection.Eager->
                            sig
                              val all :
                                ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                              val all_ignore :
                                ('a, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val sequence :
                                (Monoid.Unit.t, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val map :
                                'T.t ->
                                f:('-> ('b, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val iter :
                                'T.t ->
                                f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                init:'-> ('b, 'e) T2(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> ('a, 'e) T2(M).t) ->
                                ('a e, 'e) T2(M).t
                              val exists :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val for_all :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val count :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (Monoid.Int.t, 'e) T2(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> ('a, 'e) T2(M).t) ->
                                ('a, 'e) T2(M).t
                              val find :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('a e, 'e) T2(M).t
                              val find_map :
                                'T.t ->
                                f:('-> ('b e, 'e) T2(M).t) ->
                                ('b e, 'e) T2(M).t
                              val filter :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> ('b e, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                            end
                        module Delay :
                          functor (T : Collection.Delay->
                            sig
                              val all :
                                ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                              val all_ignore :
                                ('a, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val sequence :
                                (Monoid.Unit.t, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val map :
                                'T.t ->
                                f:('-> ('b, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val iter :
                                'T.t ->
                                f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                init:'-> ('b, 'e) T2(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> ('a, 'e) T2(M).t) ->
                                ('a e, 'e) T2(M).t
                              val exists :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val for_all :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val count :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (Monoid.Int.t, 'e) T2(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> ('a, 'e) T2(M).t) ->
                                ('a, 'e) T2(M).t
                              val find :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('a e, 'e) T2(M).t
                              val find_map :
                                'T.t ->
                                f:('-> ('b e, 'e) T2(M).t) ->
                                ('b e, 'e) T2(M).t
                              val filter :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> ('b e, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                            end
                      end
                    module List :
                      sig
                        val all :
                          ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t list ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t list ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'a list ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                        val iter :
                          'a list ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'a list ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'a list ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'a list ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'a list ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('a e, 'e) T2(M).t
                        val exists :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b list ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
                        val find_map :
                          'a list ->
                          f:('-> ('b e, 'e) T2(M).t) -> ('b e, 'e) T2(M).t
                        val filter :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('a list, 'e) T2(M).t
                        val filter_map :
                          'a list ->
                          f:('-> ('b e, 'e) T2(M).t) ->
                          ('b list, 'e) T2(M).t
                      end
                    module Seq :
                      sig
                        val all :
                          ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t
                          Core_kernel.Std.Sequence.t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('b, 'e) T2(M).t) ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                        val iter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'Core_kernel.Std.Sequence.t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'Core_kernel.Std.Sequence.t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('a e, 'e) T2(M).t
                        val exists :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
                        val find_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('b e, 'e) T2(M).t) -> ('b e, 'e) T2(M).t
                        val filter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                        val filter_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('b e, 'e) T2(M).t) ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                      end
                    val ( >=> ) :
                      ('-> ('b, 'e) T2(M).t) ->
                      ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                    val ( !! ) : '-> ('a, 'e) T2(M).t
                    val ( !$ ) :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) T2(M).t
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                        module Let_syntax :
                          sig
                            val return : '-> ('a, 'b) T2(M).t
                            val bind :
                              ('a, 'e) T2(M).t ->
                              f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                            val map :
                              ('a, 'e) T2(M).t ->
                              f:('-> 'b) -> ('b, 'e) T2(M).t
                            val both :
                              ('a, 'e) T2(M).t ->
                              ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                      end
                    val bind :
                      ('a, 'e) T2(M).t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val return : '-> ('a, 'b) T2(M).t
                    val map :
                      ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                    val join :
                      (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val ignore_m :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                    val all_ignore :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    module Syntax :
                      sig
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                        val ( >=> ) :
                          ('-> ('b, 'e) T2(M).t) ->
                          ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                        val ( !! ) : '-> ('a, 'e) T2(M).t
                        val ( !$ ) :
                          ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t ->
                          ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t ->
                          ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                      end
                    val pure : '-> ('a, 'e) T2(M).t
                    val accept : '-> ('a, 'e) T2(M).t
                    val reject : Monoid.Unit.t -> ('a, 'e) T2(M).t
                    val guard : bool -> (Monoid.Unit.t, 'e) T2(M).t
                    val on :
                      bool ->
                      (Monoid.Unit.t, 'e) T2(M).t ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val unless :
                      bool ->
                      (Monoid.Unit.t, 'e) T2(M).t ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val zero : Monoid.Unit.t -> ('a, 'e) T2(M).t
                    val plus :
                      ('a, 'e) T2(M).t ->
                      ('a, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    type 'a error = Monoid.Unit.t
                    val fail : Monoid.Unit.t -> ('a, 'e) T2(M).t
                    val catch :
                      ('a, 'e) T2(M).t ->
                      (Monoid.Unit.t -> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                  end
            end
          module Result :
            sig
              type ('a, 'e) result =
                ('a, 'e) Core_kernel.Std.Result.t =
                  Ok of 'a
                | Error of 'e
              module type S =
                sig
                  type err
                  type 'a t
                  type 'a m
                  type 'a e
                  val lift : 'a m -> 'a t
                  val run : 'a t -> 'a e
                  val void : 'a t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
                  val forever : 'a t -> 'b t
                  module Fn :
                    sig
                      val id : '-> 'a t
                      val ignore : 'a t -> Monoid.Unit.t t
                      val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                      val non : ('-> bool t) -> '-> bool t
                      val apply_n_times :
                        n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                      val compose :
                        ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                    end
                  module Pair :
                    sig
                      val fst : ('a * 'b) t -> 'a t
                      val snd : ('a * 'b) t -> 'b t
                    end
                  module Triple :
                    sig
                      val fst : ('a * 'b * 'c) t -> 'a t
                      val snd : ('a * 'b * 'c) t -> 'b t
                      val trd : ('a * 'b * 'c) t -> 'c t
                    end
                  module Lift :
                    sig
                      val nullary : '-> 'a t
                      val unary : ('-> 'b) -> 'a t -> 'b t
                      val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ternary :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val quaternary :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val quinary :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                  module Exn :
                    sig
                      val expect :
                        ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                        f:(Monoid.Unit.t -> 'a t) ->
                        catch:(exn -> 'a t) -> 'a t
                    end
                  module Collection :
                    sig
                      module type S =
                        sig
                          type 'a t
                          val all : 'a t t -> 'a t t
                          val all_ignore : 'a t t -> Monoid.Unit.t t
                          val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                          val map : 'a t -> f:('-> 'b t) -> 'b t t
                          val iter :
                            'a t ->
                            f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                          val fold :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_left :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_right :
                            'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                          val reduce :
                            'a t -> f:('-> '-> 'a t) -> 'Option.t t
                          val exists : 'a t -> f:('-> bool t) -> bool t
                          val for_all : 'a t -> f:('-> bool t) -> bool t
                          val count :
                            'a t -> f:('-> bool t) -> Monoid.Int.t t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b t -> f:('-> 'a t) -> 'a t
                          val find :
                            'a t -> f:('-> bool t) -> 'Option.t t
                          val find_map :
                            'a t -> f:('-> 'Option.t t) -> 'Option.t t
                          val filter : 'a t -> f:('-> bool t) -> 'a t t
                          val filter_map :
                            'a t -> f:('-> 'Option.t t) -> 'b t t
                        end
                      module Eager :
                        functor (T : Collection.Eager->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'Option.t t
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t t) -> 'Option.t t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'Option.t t) -> 'T.t t
                          end
                      module Delay :
                        functor (T : Collection.Delay->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'Option.t t
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t t) -> 'Option.t t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'Option.t t) -> 'T.t t
                          end
                    end
                  module List :
                    sig
                      val all : 'a t list -> 'a list t
                      val all_ignore : 'a t list -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
                      val map : 'a list -> f:('-> 'b t) -> 'b list t
                      val iter :
                        'a list ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'a list -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'a list -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'a list -> f:('-> bool t) -> bool t
                      val for_all : 'a list -> f:('-> bool t) -> bool t
                      val count :
                        'a list -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b list -> f:('-> 'a t) -> 'a t
                      val find : 'a list -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'a list -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter : 'a list -> f:('-> bool t) -> 'a list t
                      val filter_map :
                        'a list -> f:('-> 'Option.t t) -> 'b list t
                    end
                  module Seq :
                    sig
                      val all :
                        'a t Core_kernel.Std.Sequence.t ->
                        'Core_kernel.Std.Sequence.t t
                      val all_ignore :
                        'a t Core_kernel.Std.Sequence.t -> Monoid.Unit.t t
                      val sequence :
                        Monoid.Unit.t t Core_kernel.Std.Sequence.t ->
                        Monoid.Unit.t t
                      val map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> 'b t) -> 'Core_kernel.Std.Sequence.t t
                      val iter :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'Core_kernel.Std.Sequence.t ->
                        init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'Core_kernel.Std.Sequence.t ->
                        init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> '-> 'a t) -> 'Option.t t
                      val exists :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> bool t
                      val for_all :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> bool t
                      val count :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> 'a t) -> 'a t
                      val find :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> 'Option.t t) -> 'Option.t t
                      val filter :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> 'Core_kernel.Std.Sequence.t t
                      val filter_map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> 'Option.t t) ->
                        'Core_kernel.Std.Sequence.t t
                    end
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Monad_infix :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                    end
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val return : '-> 'a t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val join : 'a t t -> 'a t
                  val ignore_m : 'a t -> Monoid.Unit.t t
                  val all : 'a t list -> 'a list t
                  val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      module Let_syntax :
                        sig
                          val return : '-> 'a t
                          val bind : 'a t -> f:('-> 'b t) -> 'b t
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val both : 'a t -> 'b t -> ('a * 'b) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Syntax :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      val ( >=> ) :
                        ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                      val ( !! ) : '-> 'a t
                      val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                      val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                  type 'a error = err
                  val fail : err -> 'a t
                  val catch : 'a t -> (err -> 'a t) -> 'a t
                end
              module type S2 =
                sig
                  type ('a, 'e) t
                  type 'a m
                  type ('a, 'e) e
                  val lift : 'a m -> ('a, 'e) t
                  val run : ('a, 'e) t -> ('a, 'e) e
                  val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                  val forever : ('a, 'e) t -> ('b, 'e) t
                  module Fn :
                    sig
                      val id : '-> ('a, 'e) t
                      val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                      val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                      val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                      val apply_n_times :
                        n:Monoid.Int.t ->
                        ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                      val compose :
                        ('-> ('c, 'e) t) ->
                        ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                    end
                  module Pair :
                    sig
                      val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                      val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                    end
                  module Triple :
                    sig
                      val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                      val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                      val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                    end
                  module Lift :
                    sig
                      val nullary : '-> ('a, 'e) t
                      val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                      val binary :
                        ('-> '-> 'c) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                      val ternary :
                        ('-> '-> '-> 'd) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                      val quaternary :
                        ('-> '-> '-> '-> 'e) ->
                        ('a, 's) t ->
                        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                      val quinary :
                        ('-> '-> '-> '-> '-> 'f) ->
                        ('a, 's) t ->
                        ('b, 's) t ->
                        ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                    end
                  module Exn :
                    sig
                      val expect :
                        ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                        f:(Monoid.Unit.t -> ('a, 's) t) ->
                        catch:(exn -> ('a, 's) t) -> ('a, 's) t
                    end
                  module Collection :
                    sig
                      module type S =
                        sig
                          type 'a t
                          val all : ('a, 'e) t t -> ('a t, 'e) t
                          val all_ignore :
                            ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
                          val sequence :
                            (Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
                          val map :
                            'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                          val iter :
                            'a t ->
                            f:('-> (Monoid.Unit.t, 'e) t) ->
                            (Monoid.Unit.t, 'e) t
                          val fold :
                            'a t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_left :
                            'a t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_right :
                            'a t ->
                            f:('-> '-> ('b, 'e) t) ->
                            init:'-> ('b, 'e) t
                          val reduce :
                            'a t ->
                            f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                          val exists :
                            'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val for_all :
                            'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val count :
                            'a t ->
                            f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                          val find :
                            'a t ->
                            f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                          val find_map :
                            'a t ->
                            f:('-> ('Option.t, 'e) t) ->
                            ('Option.t, 'e) t
                          val filter :
                            'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                          val filter_map :
                            'a t ->
                            f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                        end
                      module Eager :
                        functor (T : Collection.Eager->
                          sig
                            val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                            val all_ignore :
                              ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                            val sequence :
                              (Monoid.Unit.t, 'e) t T.t ->
                              (Monoid.Unit.t, 'e) t
                            val map :
                              'T.t ->
                              f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                            val iter :
                              'T.t ->
                              f:('-> (Monoid.Unit.t, 'e) t) ->
                              (Monoid.Unit.t, 'e) t
                            val fold :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_left :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> ('b, 'e) t) ->
                              init:'-> ('b, 'e) t
                            val reduce :
                              'T.t ->
                              f:('-> '-> ('a, 'e) t) ->
                              ('Option.t, 'e) t
                            val exists :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val for_all :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val count :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                            val find :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                            val find_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) ->
                              ('Option.t, 'e) t
                            val filter :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                            val filter_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                          end
                      module Delay :
                        functor (T : Collection.Delay->
                          sig
                            val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                            val all_ignore :
                              ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                            val sequence :
                              (Monoid.Unit.t, 'e) t T.t ->
                              (Monoid.Unit.t, 'e) t
                            val map :
                              'T.t ->
                              f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                            val iter :
                              'T.t ->
                              f:('-> (Monoid.Unit.t, 'e) t) ->
                              (Monoid.Unit.t, 'e) t
                            val fold :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_left :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> ('b, 'e) t) ->
                              init:'-> ('b, 'e) t
                            val reduce :
                              'T.t ->
                              f:('-> '-> ('a, 'e) t) ->
                              ('Option.t, 'e) t
                            val exists :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val for_all :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val count :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                            val find :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                            val find_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) ->
                              ('Option.t, 'e) t
                            val filter :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                            val filter_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                          end
                    end
                  module List :
                    sig
                      val all : ('a, 'e) t list -> ('a list, 'e) t
                      val all_ignore :
                        ('a, 'e) t list -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                      val map :
                        'a list -> f:('-> ('b, 'e) t) -> ('b list, 'e) t
                      val iter :
                        'a list ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'a list ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'a list ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'a list ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'a list ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'a list ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b list -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'a list ->
                        f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'a list ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'a list -> f:('-> (bool, 'e) t) -> ('a list, 'e) t
                      val filter_map :
                        'a list ->
                        f:('-> ('Option.t, 'e) t) -> ('b list, 'e) t
                    end
                  module Seq :
                    sig
                      val all :
                        ('a, 'e) t Core_kernel.Std.Sequence.t ->
                        ('Core_kernel.Std.Sequence.t, 'e) t
                      val all_ignore :
                        ('a, 'e) t Core_kernel.Std.Sequence.t ->
                        (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t Core_kernel.Std.Sequence.t ->
                        (Monoid.Unit.t, 'e) t
                      val map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> ('b, 'e) t) ->
                        ('Core_kernel.Std.Sequence.t, 'e) t
                      val iter :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'Core_kernel.Std.Sequence.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'Core_kernel.Std.Sequence.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> (bool, 'e) t) ->
                        ('Core_kernel.Std.Sequence.t, 'e) t
                      val filter_map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> ('Option.t, 'e) t) ->
                        ('Core_kernel.Std.Sequence.t, 'e) t
                    end
                  val ( >=> ) :
                    ('-> ('b, 'e) t) ->
                    ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                  val ( !! ) : '-> ('a, 'e) t
                  val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      module Let_syntax :
                        sig
                          val return : '-> ('a, 'b) t
                          val bind :
                            ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                          val both :
                            ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Monad_infix :
                    sig
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                    end
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val return : '-> ('a, 'b) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                  val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val all : ('a, 'e) t list -> ('a list, 'e) t
                  val all_ignore :
                    (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                  module Syntax :
                    sig
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      val ( >=> ) :
                        ('-> ('b, 'e) t) ->
                        ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                      val ( !! ) : '-> ('a, 'e) t
                      val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                      val ( !$$ ) :
                        ('-> '-> 'c) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        ('a, 's) t ->
                        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        ('a, 's) t ->
                        ('b, 's) t ->
                        ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                    end
                  type 'a error = 'a
                  val fail : '-> ('a, 'e) t
                  val catch : ('a, 'e) t -> ('-> ('a, 'e) t) -> ('a, 'e) t
                end
              module T1 :
                functor (T : Core_kernel.Std.T) (M : Monad->
                  sig
                    type error = T.t
                    type 'a m = 'M.t
                    type 'a t =
                        ('a, Monads.Std.Monad.Result.T1.error)
                        Monads.Std.Monad.Result.result
                        Monads.Std.Monad.Result.T1.m
                    type 'a e =
                        ('a, Monads.Std.Monad.Result.T1.error)
                        Monads.Std.Monad.Result.result
                        Monads.Std.Monad.Result.T1.m
                  end
              module T2 :
                functor (M : Monad->
                  sig
                    type 'a m = 'M.t
                    type ('a, 'e) t =
                        ('a, 'e) Monads.Std.Monad.Result.result
                        Monads.Std.Monad.Result.T2.m
                    type ('a, 'e) e =
                        ('a, 'e) Monads.Std.Monad.Result.result
                        Monads.Std.Monad.Result.T2.m
                  end
              module Make :
                functor (T : Core_kernel.Std.T) (M : Monad->
                  sig
                    val lift : 'M.t -> 'T1(T)(M).t
                    val run : 'T1(T)(M).t -> 'T1(T)(M).e
                    val void : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                    val sequence :
                      Monoid.Unit.t T1(T)(M).t list ->
                      Monoid.Unit.t T1(T)(M).t
                    val forever : 'T1(T)(M).t -> 'T1(T)(M).t
                    module Fn :
                      sig
                        val id : '-> 'T1(T)(M).t
                        val ignore :
                          'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                        val nothing :
                          Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t
                        val non :
                          ('-> bool T1(T)(M).t) -> '-> bool T1(T)(M).t
                        val apply_n_times :
                          n:Monoid.Int.t ->
                          ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                        val compose :
                          ('-> 'T1(T)(M).t) ->
                          ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                      end
                    module Pair :
                      sig
                        val fst : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                        val snd : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                      end
                    module Triple :
                      sig
                        val fst : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                        val snd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                        val trd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                      end
                    module Lift :
                      sig
                        val nullary : '-> 'T1(T)(M).t
                        val unary :
                          ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val binary :
                          ('-> '-> 'c) ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ternary :
                          ('-> '-> '-> 'd) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val quaternary :
                          ('-> '-> '-> '-> 'e) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val quinary :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                      end
                    module Exn :
                      sig
                        val expect :
                          ?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t) ->
                          f:(Monoid.Unit.t -> 'T1(T)(M).t) ->
                          catch:(exn -> 'T1(T)(M).t) -> 'T1(T)(M).t
                      end
                    module Collection :
                      sig
                        module type S =
                          sig
                            type 'a t
                            val all : 'T1(T)(M).t t -> 'a t T1(T)(M).t
                            val all_ignore :
                              'T1(T)(M).t t -> Monoid.Unit.t T1(T)(M).t
                            val sequence :
                              Monoid.Unit.t T1(T)(M).t t ->
                              Monoid.Unit.t T1(T)(M).t
                            val map :
                              'a t ->
                              f:('-> 'T1(T)(M).t) -> 'b t T1(T)(M).t
                            val iter :
                              'a t ->
                              f:('-> Monoid.Unit.t T1(T)(M).t) ->
                              Monoid.Unit.t T1(T)(M).t
                            val fold :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val fold_left :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val fold_right :
                              'a t ->
                              f:('-> '-> 'T1(T)(M).t) ->
                              init:'-> 'T1(T)(M).t
                            val reduce :
                              'a t ->
                              f:('-> '-> 'T1(T)(M).t) ->
                              'Option.t T1(T)(M).t
                            val exists :
                              'a t ->
                              f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                            val for_all :
                              'a t ->
                              f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                            val count :
                              'a t ->
                              f:('-> bool T1(T)(M).t) ->
                              Monoid.Int.t T1(T)(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b t ->
                              f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val find :
                              'a t ->
                              f:('-> bool T1(T)(M).t) ->
                              'Option.t T1(T)(M).t
                            val find_map :
                              'a t ->
                              f:('-> 'Option.t T1(T)(M).t) ->
                              'Option.t T1(T)(M).t
                            val filter :
                              'a t ->
                              f:('-> bool T1(T)(M).t) -> 'a t T1(T)(M).t
                            val filter_map :
                              'a t ->
                              f:('-> 'Option.t T1(T)(M).t) ->
                              'b t T1(T)(M).t
                          end
                        module Eager :
                          functor (T : Collection.Eager->
                            sig
                              val all :
                                'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                              val all_ignore :
                                'T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
                              val sequence :
                                Monoid.Unit.t T1(T)(M).t T.t ->
                                Monoid.Unit.t T1(T)(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T1(T)(M).t) ->
                                Monoid.Unit.t T1(T)(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'T1(T)(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'T1(T)(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T1(T)(M).t) ->
                                init:'-> 'T1(T)(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                Monoid.Int.t T1(T)(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'Option.t T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                'T.t T1(T)(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'Option.t T1(T)(M).t) ->
                                'T.t T1(T)(M).t
                            end
                        module Delay :
                          functor (T : Collection.Delay->
                            sig
                              val all :
                                'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                              val all_ignore :
                                'T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
                              val sequence :
                                Monoid.Unit.t T1(T)(M).t T.t ->
                                Monoid.Unit.t T1(T)(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T1(T)(M).t) ->
                                Monoid.Unit.t T1(T)(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'T1(T)(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'T1(T)(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T1(T)(M).t) ->
                                init:'-> 'T1(T)(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                Monoid.Int.t T1(T)(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'Option.t T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                'T.t T1(T)(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'Option.t T1(T)(M).t) ->
                                'T.t T1(T)(M).t
                            end
                      end
                    module List :
                      sig
                        val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                        val all_ignore :
                          'T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
                        val sequence :
                          Monoid.Unit.t T1(T)(M).t list ->
                          Monoid.Unit.t T1(T)(M).t
                        val map :
                          'a list ->
                          f:('-> 'T1(T)(M).t) -> 'b list T1(T)(M).t
                        val iter :
                          'a list ->
                          f:('-> Monoid.Unit.t T1(T)(M).t) ->
                          Monoid.Unit.t T1(T)(M).t
                        val fold :
                          'a list ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_left :
                          'a list ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_right :
                          'a list ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          init:'-> 'T1(T)(M).t
                        val reduce :
                          'a list ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val exists :
                          'a list ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val for_all :
                          'a list ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val count :
                          'a list ->
                          f:('-> bool T1(T)(M).t) ->
                          Monoid.Int.t T1(T)(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b list -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val find :
                          'a list ->
                          f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                        val find_map :
                          'a list ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val filter :
                          'a list ->
                          f:('-> bool T1(T)(M).t) -> 'a list T1(T)(M).t
                        val filter_map :
                          'a list ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'b list T1(T)(M).t
                      end
                    module Seq :
                      sig
                        val all :
                          'T1(T)(M).t Core_kernel.Std.Sequence.t ->
                          'Core_kernel.Std.Sequence.t T1(T)(M).t
                        val all_ignore :
                          'T1(T)(M).t Core_kernel.Std.Sequence.t ->
                          Monoid.Unit.t T1(T)(M).t
                        val sequence :
                          Monoid.Unit.t T1(T)(M).t Core_kernel.Std.Sequence.t ->
                          Monoid.Unit.t T1(T)(M).t
                        val map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'T1(T)(M).t) ->
                          'Core_kernel.Std.Sequence.t T1(T)(M).t
                        val iter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> Monoid.Unit.t T1(T)(M).t) ->
                          Monoid.Unit.t T1(T)(M).t
                        val fold :
                          'Core_kernel.Std.Sequence.t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_left :
                          'Core_kernel.Std.Sequence.t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_right :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          init:'-> 'T1(T)(M).t
                        val reduce :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val exists :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val for_all :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val count :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(T)(M).t) ->
                          Monoid.Int.t T1(T)(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val find :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                        val find_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val filter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(T)(M).t) ->
                          'Core_kernel.Std.Sequence.t T1(T)(M).t
                        val filter_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'Core_kernel.Std.Sequence.t T1(T)(M).t
                      end
                    val ( >=> ) :
                      ('-> 'T1(T)(M).t) ->
                      ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                    val ( !! ) : '-> 'T1(T)(M).t
                    val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( >>= ) :
                      'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val ( >>| ) :
                      'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          'T1(T)(M).t ->
                          ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val ( >>| ) :
                          'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                      end
                    val bind :
                      'T1(T)(M).t ->
                      f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val return : '-> 'T1(T)(M).t
                    val map : 'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                    val join : 'T1(T)(M).t T1(T)(M).t -> 'T1(T)(M).t
                    val ignore_m : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                    val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                    val all_ignore :
                      Monoid.Unit.t T1(T)(M).t list ->
                      Monoid.Unit.t T1(T)(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T1(T)(M).t
                        val ( >>= ) :
                          'T1(T)(M).t ->
                          ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val ( >>| ) :
                          'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                        module Let_syntax :
                          sig
                            val return : '-> 'T1(T)(M).t
                            val bind :
                              'T1(T)(M).t ->
                              f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val map :
                              'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                            val both :
                              'T1(T)(M).t ->
                              'T1(T)(M).t -> ('a * 'b) T1(T)(M).t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Syntax :
                      sig
                        val ( >>= ) :
                          'T1(T)(M).t ->
                          ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val ( >>| ) :
                          'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                        val ( >=> ) :
                          ('-> 'T1(T)(M).t) ->
                          ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                        val ( !! ) : '-> 'T1(T)(M).t
                        val ( !$ ) :
                          ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                      end
                    type 'a error = T.t
                    val fail : T.t -> 'T1(T)(M).t
                    val catch :
                      'T1(T)(M).t ->
                      (T.t -> 'T1(T)(M).t) -> 'T1(T)(M).t
                  end
              module Make2 :
                functor (M : Monad->
                  sig
                    val lift : 'M.t -> ('a, 'e) T2(M).t
                    val run : ('a, 'e) T2(M).t -> ('a, 'e) T2(M).e
                    val void :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    module Fn :
                      sig
                        val id : '-> ('a, 'e) T2(M).t
                        val ignore :
                          ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                        val nothing :
                          Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
                        val non :
                          ('-> (bool, 'e) T2(M).t) ->
                          '-> (bool, 'e) T2(M).t
                        val apply_n_times :
                          n:Monoid.Int.t ->
                          ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                        val compose :
                          ('-> ('c, 'e) T2(M).t) ->
                          ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                      end
                    module Pair :
                      sig
                        val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                        val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
                      end
                    module Triple :
                      sig
                        val fst :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                        val snd :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val trd :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
                      end
                    module Lift :
                      sig
                        val nullary : '-> ('a, 'e) T2(M).t
                        val unary :
                          ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val binary :
                          ('-> '-> 'c) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                        val ternary :
                          ('-> '-> '-> 'd) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t ->
                          ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                        val quaternary :
                          ('-> '-> '-> '-> 'e) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                        val quinary :
                          ('-> '-> '-> '-> '-> 'f) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t ->
                          ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                      end
                    module Exn :
                      sig
                        val expect :
                          ?finally:(Monoid.Unit.t ->
                                    (Monoid.Unit.t, 's) T2(M).t) ->
                          f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
                          catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
                      end
                    module Collection :
                      sig
                        module type S =
                          sig
                            type 'a t
                            val all :
                              ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                            val all_ignore :
                              ('a, 'e) T2(M).t t ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val sequence :
                              (Monoid.Unit.t, 'e) T2(M).t t ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val map :
                              'a t ->
                              f:('-> ('b, 'e) T2(M).t) ->
                              ('b t, 'e) T2(M).t
                            val iter :
                              'a t ->
                              f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val fold :
                              'a t ->
                              init:'->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              ('b, 'e) T2(M).t
                            val fold_left :
                              'a t ->
                              init:'->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              ('b, 'e) T2(M).t
                            val fold_right :
                              'a t ->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              init:'-> ('b, 'e) T2(M).t
                            val reduce :
                              'a t ->
                              f:('-> '-> ('a, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val exists :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (bool, 'e) T2(M).t
                            val for_all :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (bool, 'e) T2(M).t
                            val count :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (Monoid.Int.t, 'e) T2(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b t ->
                              f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                            val find :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val find_map :
                              'a t ->
                              f:('-> ('Option.t, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val filter :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              ('a t, 'e) T2(M).t
                            val filter_map :
                              'a t ->
                              f:('-> ('Option.t, 'e) T2(M).t) ->
                              ('b t, 'e) T2(M).t
                          end
                        module Eager :
                          functor (T : Collection.Eager->
                            sig
                              val all :
                                ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                              val all_ignore :
                                ('a, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val sequence :
                                (Monoid.Unit.t, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val map :
                                'T.t ->
                                f:('-> ('b, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val iter :
                                'T.t ->
                                f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                init:'-> ('b, 'e) T2(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> ('a, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val exists :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val for_all :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val count :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (Monoid.Int.t, 'e) T2(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> ('a, 'e) T2(M).t) ->
                                ('a, 'e) T2(M).t
                              val find :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val find_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val filter :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                            end
                        module Delay :
                          functor (T : Collection.Delay->
                            sig
                              val all :
                                ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                              val all_ignore :
                                ('a, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val sequence :
                                (Monoid.Unit.t, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val map :
                                'T.t ->
                                f:('-> ('b, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val iter :
                                'T.t ->
                                f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                init:'-> ('b, 'e) T2(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> ('a, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val exists :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val for_all :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val count :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (Monoid.Int.t, 'e) T2(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> ('a, 'e) T2(M).t) ->
                                ('a, 'e) T2(M).t
                              val find :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val find_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val filter :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                            end
                      end
                    module List :
                      sig
                        val all :
                          ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t list ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t list ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'a list ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                        val iter :
                          'a list ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'a list ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'a list ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'a list ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'a list ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b list ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'a list ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('a list, 'e) T2(M).t
                        val filter_map :
                          'a list ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('b list, 'e) T2(M).t
                      end
                    module Seq :
                      sig
                        val all :
                          ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t
                          Core_kernel.Std.Sequence.t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('b, 'e) T2(M).t) ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                        val iter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'Core_kernel.Std.Sequence.t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'Core_kernel.Std.Sequence.t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                        val filter_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                      end
                    val ( >=> ) :
                      ('-> ('b, 'e) T2(M).t) ->
                      ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                    val ( !! ) : '-> ('a, 'e) T2(M).t
                    val ( !$ ) :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) T2(M).t
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                        module Let_syntax :
                          sig
                            val return : '-> ('a, 'b) T2(M).t
                            val bind :
                              ('a, 'e) T2(M).t ->
                              f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                            val map :
                              ('a, 'e) T2(M).t ->
                              f:('-> 'b) -> ('b, 'e) T2(M).t
                            val both :
                              ('a, 'e) T2(M).t ->
                              ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                      end
                    val bind :
                      ('a, 'e) T2(M).t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val return : '-> ('a, 'b) T2(M).t
                    val map :
                      ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                    val join :
                      (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val ignore_m :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                    val all_ignore :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    module Syntax :
                      sig
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                        val ( >=> ) :
                          ('-> ('b, 'e) T2(M).t) ->
                          ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                        val ( !! ) : '-> ('a, 'e) T2(M).t
                        val ( !$ ) :
                          ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t ->
                          ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t ->
                          ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                      end
                    type 'a error = 'a
                    val fail : '-> ('a, 'e) T2(M).t
                    val catch :
                      ('a, 'e) T2(M).t ->
                      ('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                  end
              module Error :
                sig
                  module type S =
                    sig
                      type err
                      type 'a t
                      type 'a m
                      type 'a e
                      val lift : 'a m -> 'a t
                      val run : 'a t -> 'a e
                      val void : 'a t -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
                      val forever : 'a t -> 'b t
                      module Fn :
                        sig
                          val id : '-> 'a t
                          val ignore : 'a t -> Monoid.Unit.t t
                          val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                          val non : ('-> bool t) -> '-> bool t
                          val apply_n_times :
                            n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                          val compose :
                            ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                        end
                      module Pair :
                        sig
                          val fst : ('a * 'b) t -> 'a t
                          val snd : ('a * 'b) t -> 'b t
                        end
                      module Triple :
                        sig
                          val fst : ('a * 'b * 'c) t -> 'a t
                          val snd : ('a * 'b * 'c) t -> 'b t
                          val trd : ('a * 'b * 'c) t -> 'c t
                        end
                      module Lift :
                        sig
                          val nullary : '-> 'a t
                          val unary : ('-> 'b) -> 'a t -> 'b t
                          val binary :
                            ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                          val ternary :
                            ('-> '-> '-> 'd) ->
                            'a t -> 'b t -> 'c t -> 'd t
                          val quaternary :
                            ('-> '-> '-> '-> 'e) ->
                            'a t -> 'b t -> 'c t -> 'd t -> 'e t
                          val quinary :
                            ('-> '-> '-> '-> '-> 'f) ->
                            'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                        end
                      module Exn :
                        sig
                          val expect :
                            ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                            f:(Monoid.Unit.t -> 'a t) ->
                            catch:(exn -> 'a t) -> 'a t
                        end
                      module Collection :
                        sig
                          module type S =
                            sig
                              type 'a t
                              val all : 'a t t -> 'a t t
                              val all_ignore : 'a t t -> Monoid.Unit.t t
                              val sequence :
                                Monoid.Unit.t t t -> Monoid.Unit.t t
                              val map : 'a t -> f:('-> 'b t) -> 'b t t
                              val iter :
                                'a t ->
                                f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                              val fold :
                                'a t ->
                                init:'-> f:('-> '-> 'b t) -> 'b t
                              val fold_left :
                                'a t ->
                                init:'-> f:('-> '-> 'b t) -> 'b t
                              val fold_right :
                                'a t ->
                                f:('-> '-> 'b t) -> init:'-> 'b t
                              val reduce :
                                'a t -> f:('-> '-> 'a t) -> 'Option.t t
                              val exists : 'a t -> f:('-> bool t) -> bool t
                              val for_all :
                                'a t -> f:('-> bool t) -> bool t
                              val count :
                                'a t -> f:('-> bool t) -> Monoid.Int.t t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'b t -> f:('-> 'a t) -> 'a t
                              val find :
                                'a t -> f:('-> bool t) -> 'Option.t t
                              val find_map :
                                'a t ->
                                f:('-> 'Option.t t) -> 'Option.t t
                              val filter : 'a t -> f:('-> bool t) -> 'a t t
                              val filter_map :
                                'a t -> f:('-> 'Option.t t) -> 'b t t
                            end
                          module Eager :
                            functor (T : Collection.Eager->
                              sig
                                val all : 'a t T.t -> 'T.t t
                                val all_ignore : 'a t T.t -> Monoid.Unit.t t
                                val sequence :
                                  Monoid.Unit.t t T.t -> Monoid.Unit.t t
                                val map :
                                  'T.t -> f:('-> 'b t) -> 'T.t t
                                val iter :
                                  'T.t ->
                                  f:('-> Monoid.Unit.t t) ->
                                  Monoid.Unit.t t
                                val fold :
                                  'T.t ->
                                  init:'-> f:('-> '-> 'b t) -> 'b t
                                val fold_left :
                                  'T.t ->
                                  init:'-> f:('-> '-> 'b t) -> 'b t
                                val fold_right :
                                  'T.t ->
                                  f:('-> '-> 'b t) -> init:'-> 'b t
                                val reduce :
                                  'T.t ->
                                  f:('-> '-> 'a t) -> 'Option.t t
                                val exists :
                                  'T.t -> f:('-> bool t) -> bool t
                                val for_all :
                                  'T.t -> f:('-> bool t) -> bool t
                                val count :
                                  'T.t ->
                                  f:('-> bool t) -> Monoid.Int.t t
                                val map_reduce :
                                  (module Monoid.S with type t = 'a) ->
                                  'T.t -> f:('-> 'a t) -> 'a t
                                val find :
                                  'T.t -> f:('-> bool t) -> 'Option.t t
                                val find_map :
                                  'T.t ->
                                  f:('-> 'Option.t t) -> 'Option.t t
                                val filter :
                                  'T.t -> f:('-> bool t) -> 'T.t t
                                val filter_map :
                                  'T.t ->
                                  f:('-> 'Option.t t) -> 'T.t t
                              end
                          module Delay :
                            functor (T : Collection.Delay->
                              sig
                                val all : 'a t T.t -> 'T.t t
                                val all_ignore : 'a t T.t -> Monoid.Unit.t t
                                val sequence :
                                  Monoid.Unit.t t T.t -> Monoid.Unit.t t
                                val map :
                                  'T.t -> f:('-> 'b t) -> 'T.t t
                                val iter :
                                  'T.t ->
                                  f:('-> Monoid.Unit.t t) ->
                                  Monoid.Unit.t t
                                val fold :
                                  'T.t ->
                                  init:'-> f:('-> '-> 'b t) -> 'b t
                                val fold_left :
                                  'T.t ->
                                  init:'-> f:('-> '-> 'b t) -> 'b t
                                val fold_right :
                                  'T.t ->
                                  f:('-> '-> 'b t) -> init:'-> 'b t
                                val reduce :
                                  'T.t ->
                                  f:('-> '-> 'a t) -> 'Option.t t
                                val exists :
                                  'T.t -> f:('-> bool t) -> bool t
                                val for_all :
                                  'T.t -> f:('-> bool t) -> bool t
                                val count :
                                  'T.t ->
                                  f:('-> bool t) -> Monoid.Int.t t
                                val map_reduce :
                                  (module Monoid.S with type t = 'a) ->
                                  'T.t -> f:('-> 'a t) -> 'a t
                                val find :
                                  'T.t -> f:('-> bool t) -> 'Option.t t
                                val find_map :
                                  'T.t ->
                                  f:('-> 'Option.t t) -> 'Option.t t
                                val filter :
                                  'T.t -> f:('-> bool t) -> 'T.t t
                                val filter_map :
                                  'T.t ->
                                  f:('-> 'Option.t t) -> 'T.t t
                              end
                        end
                      module List :
                        sig
                          val all : 'a t list -> 'a list t
                          val all_ignore : 'a t list -> Monoid.Unit.t t
                          val sequence :
                            Monoid.Unit.t t list -> Monoid.Unit.t t
                          val map : 'a list -> f:('-> 'b t) -> 'b list t
                          val iter :
                            'a list ->
                            f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                          val fold :
                            'a list ->
                            init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_left :
                            'a list ->
                            init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_right :
                            'a list ->
                            f:('-> '-> 'b t) -> init:'-> 'b t
                          val reduce :
                            'a list -> f:('-> '-> 'a t) -> 'Option.t t
                          val exists : 'a list -> f:('-> bool t) -> bool t
                          val for_all : 'a list -> f:('-> bool t) -> bool t
                          val count :
                            'a list -> f:('-> bool t) -> Monoid.Int.t t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b list -> f:('-> 'a t) -> 'a t
                          val find :
                            'a list -> f:('-> bool t) -> 'Option.t t
                          val find_map :
                            'a list ->
                            f:('-> 'Option.t t) -> 'Option.t t
                          val filter :
                            'a list -> f:('-> bool t) -> 'a list t
                          val filter_map :
                            'a list -> f:('-> 'Option.t t) -> 'b list t
                        end
                      module Seq :
                        sig
                          val all :
                            'a t Core_kernel.Std.Sequence.t ->
                            'Core_kernel.Std.Sequence.t t
                          val all_ignore :
                            'a t Core_kernel.Std.Sequence.t ->
                            Monoid.Unit.t t
                          val sequence :
                            Monoid.Unit.t t Core_kernel.Std.Sequence.t ->
                            Monoid.Unit.t t
                          val map :
                            'Core_kernel.Std.Sequence.t ->
                            f:('-> 'b t) -> 'Core_kernel.Std.Sequence.t t
                          val iter :
                            'Core_kernel.Std.Sequence.t ->
                            f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                          val fold :
                            'Core_kernel.Std.Sequence.t ->
                            init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_left :
                            'Core_kernel.Std.Sequence.t ->
                            init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_right :
                            'Core_kernel.Std.Sequence.t ->
                            f:('-> '-> 'b t) -> init:'-> 'b t
                          val reduce :
                            'Core_kernel.Std.Sequence.t ->
                            f:('-> '-> 'a t) -> 'Option.t t
                          val exists :
                            'Core_kernel.Std.Sequence.t ->
                            f:('-> bool t) -> bool t
                          val for_all :
                            'Core_kernel.Std.Sequence.t ->
                            f:('-> bool t) -> bool t
                          val count :
                            'Core_kernel.Std.Sequence.t ->
                            f:('-> bool t) -> Monoid.Int.t t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'Core_kernel.Std.Sequence.t ->
                            f:('-> 'a t) -> 'a t
                          val find :
                            'Core_kernel.Std.Sequence.t ->
                            f:('-> bool t) -> 'Option.t t
                          val find_map :
                            'Core_kernel.Std.Sequence.t ->
                            f:('-> 'Option.t t) -> 'Option.t t
                          val filter :
                            'Core_kernel.Std.Sequence.t ->
                            f:('-> bool t) ->
                            'Core_kernel.Std.Sequence.t t
                          val filter_map :
                            'Core_kernel.Std.Sequence.t ->
                            f:('-> 'Option.t t) ->
                            'Core_kernel.Std.Sequence.t t
                        end
                      val ( >=> ) :
                        ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                      val ( !! ) : '-> 'a t
                      val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                      val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      module Monad_infix :
                        sig
                          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                        end
                      val bind : 'a t -> f:('-> 'b t) -> 'b t
                      val return : '-> 'a t
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val join : 'a t t -> 'a t
                      val ignore_m : 'a t -> Monoid.Unit.t t
                      val all : 'a t list -> 'a list t
                      val all_ignore :
                        Monoid.Unit.t t list -> Monoid.Unit.t t
                      module Let_syntax :
                        sig
                          val return : '-> 'a t
                          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                          module Let_syntax :
                            sig
                              val return : '-> 'a t
                              val bind : 'a t -> f:('-> 'b t) -> 'b t
                              val map : 'a t -> f:('-> 'b) -> 'b t
                              val both : 'a t -> 'b t -> ('a * 'b) t
                              module Open_on_rhs : sig  end
                            end
                        end
                      module Syntax :
                        sig
                          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                          val ( >=> ) :
                            ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                          val ( !! ) : '-> 'a t
                          val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                          val ( !$$ ) :
                            ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                          val ( !$$$ ) :
                            ('-> '-> '-> 'd) ->
                            'a t -> 'b t -> 'c t -> 'd t
                          val ( !$$$$ ) :
                            ('-> '-> '-> '-> 'e) ->
                            'a t -> 'b t -> 'c t -> 'd t -> 'e t
                          val ( !$$$$$ ) :
                            ('-> '-> '-> '-> '-> 'f) ->
                            'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                        end
                      type 'a error = err
                      val fail : err -> 'a t
                      val catch : 'a t -> (err -> 'a t) -> 'a t
                      val failf :
                        ('a, Format.formatter, unit, unit -> 'b t)
                        Core_kernel.Std.format4 -> 'a
                    end
                  module T :
                    functor (M : Monad->
                      sig
                        type 'a m = 'M.t
                        type 'a t =
                            'Core_kernel.Std.Or_error.t
                            Monads.Std.Monad.Result.Error.T.m
                        type 'a e =
                            'Core_kernel.Std.Or_error.t
                            Monads.Std.Monad.Result.Error.T.m
                      end
                  module Make :
                    functor (M : Monad->
                      sig
                        val lift : 'M.t -> 'T(M).t
                        val run : 'T(M).t -> 'T(M).e
                        val void : 'T(M).t -> Monoid.Unit.t T(M).t
                        val sequence :
                          Monoid.Unit.t T(M).t list -> Monoid.Unit.t T(M).t
                        val forever : 'T(M).t -> 'T(M).t
                        module Fn :
                          sig
                            val id : '-> 'T(M).t
                            val ignore : 'T(M).t -> Monoid.Unit.t T(M).t
                            val nothing :
                              Monoid.Unit.t -> Monoid.Unit.t T(M).t
                            val non :
                              ('-> bool T(M).t) -> '-> bool T(M).t
                            val apply_n_times :
                              n:Monoid.Int.t ->
                              ('-> 'T(M).t) -> '-> 'T(M).t
                            val compose :
                              ('-> 'T(M).t) ->
                              ('-> 'T(M).t) -> '-> 'T(M).t
                          end
                        module Pair :
                          sig
                            val fst : ('a * 'b) T(M).t -> 'T(M).t
                            val snd : ('a * 'b) T(M).t -> 'T(M).t
                          end
                        module Triple :
                          sig
                            val fst : ('a * 'b * 'c) T(M).t -> 'T(M).t
                            val snd : ('a * 'b * 'c) T(M).t -> 'T(M).t
                            val trd : ('a * 'b * 'c) T(M).t -> 'T(M).t
                          end
                        module Lift :
                          sig
                            val nullary : '-> 'T(M).t
                            val unary : ('-> 'b) -> 'T(M).t -> 'T(M).t
                            val binary :
                              ('-> '-> 'c) ->
                              'T(M).t -> 'T(M).t -> 'T(M).t
                            val ternary :
                              ('-> '-> '-> 'd) ->
                              'T(M).t ->
                              'T(M).t -> 'T(M).t -> 'T(M).t
                            val quaternary :
                              ('-> '-> '-> '-> 'e) ->
                              'T(M).t ->
                              'T(M).t ->
                              'T(M).t -> 'T(M).t -> 'T(M).t
                            val quinary :
                              ('-> '-> '-> '-> '-> 'f) ->
                              'T(M).t ->
                              'T(M).t ->
                              'T(M).t ->
                              'T(M).t -> 'T(M).t -> 'T(M).t
                          end
                        module Exn :
                          sig
                            val expect :
                              ?finally:(Monoid.Unit.t -> Monoid.Unit.t T(M).t) ->
                              f:(Monoid.Unit.t -> 'T(M).t) ->
                              catch:(exn -> 'T(M).t) -> 'T(M).t
                          end
                        module Collection :
                          sig
                            module type S =
                              sig
                                type 'a t
                                val all : 'T(M).t t -> 'a t T(M).t
                                val all_ignore :
                                  'T(M).t t -> Monoid.Unit.t T(M).t
                                val sequence :
                                  Monoid.Unit.t T(M).t t ->
                                  Monoid.Unit.t T(M).t
                                val map :
                                  'a t -> f:('-> 'T(M).t) -> 'b t T(M).t
                                val iter :
                                  'a t ->
                                  f:('-> Monoid.Unit.t T(M).t) ->
                                  Monoid.Unit.t T(M).t
                                val fold :
                                  'a t ->
                                  init:'->
                                  f:('-> '-> 'T(M).t) -> 'T(M).t
                                val fold_left :
                                  'a t ->
                                  init:'->
                                  f:('-> '-> 'T(M).t) -> 'T(M).t
                                val fold_right :
                                  'a t ->
                                  f:('-> '-> 'T(M).t) ->
                                  init:'-> 'T(M).t
                                val reduce :
                                  'a t ->
                                  f:('-> '-> 'T(M).t) ->
                                  'Option.t T(M).t
                                val exists :
                                  'a t ->
                                  f:('-> bool T(M).t) -> bool T(M).t
                                val for_all :
                                  'a t ->
                                  f:('-> bool T(M).t) -> bool T(M).t
                                val count :
                                  'a t ->
                                  f:('-> bool T(M).t) ->
                                  Monoid.Int.t T(M).t
                                val map_reduce :
                                  (module Monoid.S with type t = 'a) ->
                                  'b t -> f:('-> 'T(M).t) -> 'T(M).t
                                val find :
                                  'a t ->
                                  f:('-> bool T(M).t) -> 'Option.t T(M).t
                                val find_map :
                                  'a t ->
                                  f:('-> 'Option.t T(M).t) ->
                                  'Option.t T(M).t
                                val filter :
                                  'a t ->
                                  f:('-> bool T(M).t) -> 'a t T(M).t
                                val filter_map :
                                  'a t ->
                                  f:('-> 'Option.t T(M).t) -> 'b t T(M).t
                              end
                            module Eager :
                              functor (T : Collection.Eager->
                                sig
                                  val all : 'T(M).t T.t -> 'T.t T(M).t
                                  val all_ignore :
                                    'T(M).t T.t -> Monoid.Unit.t T(M).t
                                  val sequence :
                                    Monoid.Unit.t T(M).t T.t ->
                                    Monoid.Unit.t T(M).t
                                  val map :
                                    'T.t ->
                                    f:('-> 'T(M).t) -> 'T.t T(M).t
                                  val iter :
                                    'T.t ->
                                    f:('-> Monoid.Unit.t T(M).t) ->
                                    Monoid.Unit.t T(M).t
                                  val fold :
                                    'T.t ->
                                    init:'->
                                    f:('-> '-> 'T(M).t) -> 'T(M).t
                                  val fold_left :
                                    'T.t ->
                                    init:'->
                                    f:('-> '-> 'T(M).t) -> 'T(M).t
                                  val fold_right :
                                    'T.t ->
                                    f:('-> '-> 'T(M).t) ->
                                    init:'-> 'T(M).t
                                  val reduce :
                                    'T.t ->
                                    f:('-> '-> 'T(M).t) ->
                                    'Option.t T(M).t
                                  val exists :
                                    'T.t ->
                                    f:('-> bool T(M).t) -> bool T(M).t
                                  val for_all :
                                    'T.t ->
                                    f:('-> bool T(M).t) -> bool T(M).t
                                  val count :
                                    'T.t ->
                                    f:('-> bool T(M).t) ->
                                    Monoid.Int.t T(M).t
                                  val map_reduce :
                                    (module Monoid.S with type t = 'a) ->
                                    'T.t ->
                                    f:('-> 'T(M).t) -> 'T(M).t
                                  val find :
                                    'T.t ->
                                    f:('-> bool T(M).t) ->
                                    'Option.t T(M).t
                                  val find_map :
                                    'T.t ->
                                    f:('-> 'Option.t T(M).t) ->
                                    'Option.t T(M).t
                                  val filter :
                                    'T.t ->
                                    f:('-> bool T(M).t) -> 'T.t T(M).t
                                  val filter_map :
                                    'T.t ->
                                    f:('-> 'Option.t T(M).t) ->
                                    'T.t T(M).t
                                end
                            module Delay :
                              functor (T : Collection.Delay->
                                sig
                                  val all : 'T(M).t T.t -> 'T.t T(M).t
                                  val all_ignore :
                                    'T(M).t T.t -> Monoid.Unit.t T(M).t
                                  val sequence :
                                    Monoid.Unit.t T(M).t T.t ->
                                    Monoid.Unit.t T(M).t
                                  val map :
                                    'T.t ->
                                    f:('-> 'T(M).t) -> 'T.t T(M).t
                                  val iter :
                                    'T.t ->
                                    f:('-> Monoid.Unit.t T(M).t) ->
                                    Monoid.Unit.t T(M).t
                                  val fold :
                                    'T.t ->
                                    init:'->
                                    f:('-> '-> 'T(M).t) -> 'T(M).t
                                  val fold_left :
                                    'T.t ->
                                    init:'->
                                    f:('-> '-> 'T(M).t) -> 'T(M).t
                                  val fold_right :
                                    'T.t ->
                                    f:('-> '-> 'T(M).t) ->
                                    init:'-> 'T(M).t
                                  val reduce :
                                    'T.t ->
                                    f:('-> '-> 'T(M).t) ->
                                    'Option.t T(M).t
                                  val exists :
                                    'T.t ->
                                    f:('-> bool T(M).t) -> bool T(M).t
                                  val for_all :
                                    'T.t ->
                                    f:('-> bool T(M).t) -> bool T(M).t
                                  val count :
                                    'T.t ->
                                    f:('-> bool T(M).t) ->
                                    Monoid.Int.t T(M).t
                                  val map_reduce :
                                    (module Monoid.S with type t = 'a) ->
                                    'T.t ->
                                    f:('-> 'T(M).t) -> 'T(M).t
                                  val find :
                                    'T.t ->
                                    f:('-> bool T(M).t) ->
                                    'Option.t T(M).t
                                  val find_map :
                                    'T.t ->
                                    f:('-> 'Option.t T(M).t) ->
                                    'Option.t T(M).t
                                  val filter :
                                    'T.t ->
                                    f:('-> bool T(M).t) -> 'T.t T(M).t
                                  val filter_map :
                                    'T.t ->
                                    f:('-> 'Option.t T(M).t) ->
                                    'T.t T(M).t
                                end
                          end
                        module List :
                          sig
                            val all : 'T(M).t list -> 'a list T(M).t
                            val all_ignore :
                              'T(M).t list -> Monoid.Unit.t T(M).t
                            val sequence :
                              Monoid.Unit.t T(M).t list ->
                              Monoid.Unit.t T(M).t
                            val map :
                              'a list ->
                              f:('-> 'T(M).t) -> 'b list T(M).t
                            val iter :
                              'a list ->
                              f:('-> Monoid.Unit.t T(M).t) ->
                              Monoid.Unit.t T(M).t
                            val fold :
                              'a list ->
                              init:'->
                              f:('-> '-> 'T(M).t) -> 'T(M).t
                            val fold_left :
                              'a list ->
                              init:'->
                              f:('-> '-> 'T(M).t) -> 'T(M).t
                            val fold_right :
                              'a list ->
                              f:('-> '-> 'T(M).t) ->
                              init:'-> 'T(M).t
                            val reduce :
                              'a list ->
                              f:('-> '-> 'T(M).t) -> 'Option.t T(M).t
                            val exists :
                              'a list -> f:('-> bool T(M).t) -> bool T(M).t
                            val for_all :
                              'a list -> f:('-> bool T(M).t) -> bool T(M).t
                            val count :
                              'a list ->
                              f:('-> bool T(M).t) -> Monoid.Int.t T(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b list -> f:('-> 'T(M).t) -> 'T(M).t
                            val find :
                              'a list ->
                              f:('-> bool T(M).t) -> 'Option.t T(M).t
                            val find_map :
                              'a list ->
                              f:('-> 'Option.t T(M).t) ->
                              'Option.t T(M).t
                            val filter :
                              'a list ->
                              f:('-> bool T(M).t) -> 'a list T(M).t
                            val filter_map :
                              'a list ->
                              f:('-> 'Option.t T(M).t) -> 'b list T(M).t
                          end
                        module Seq :
                          sig
                            val all :
                              'T(M).t Core_kernel.Std.Sequence.t ->
                              'Core_kernel.Std.Sequence.t T(M).t
                            val all_ignore :
                              'T(M).t Core_kernel.Std.Sequence.t ->
                              Monoid.Unit.t T(M).t
                            val sequence :
                              Monoid.Unit.t T(M).t Core_kernel.Std.Sequence.t ->
                              Monoid.Unit.t T(M).t
                            val map :
                              'Core_kernel.Std.Sequence.t ->
                              f:('-> 'T(M).t) ->
                              'Core_kernel.Std.Sequence.t T(M).t
                            val iter :
                              'Core_kernel.Std.Sequence.t ->
                              f:('-> Monoid.Unit.t T(M).t) ->
                              Monoid.Unit.t T(M).t
                            val fold :
                              'Core_kernel.Std.Sequence.t ->
                              init:'->
                              f:('-> '-> 'T(M).t) -> 'T(M).t
                            val fold_left :
                              'Core_kernel.Std.Sequence.t ->
                              init:'->
                              f:('-> '-> 'T(M).t) -> 'T(M).t
                            val fold_right :
                              'Core_kernel.Std.Sequence.t ->
                              f:('-> '-> 'T(M).t) ->
                              init:'-> 'T(M).t
                            val reduce :
                              'Core_kernel.Std.Sequence.t ->
                              f:('-> '-> 'T(M).t) -> 'Option.t T(M).t
                            val exists :
                              'Core_kernel.Std.Sequence.t ->
                              f:('-> bool T(M).t) -> bool T(M).t
                            val for_all :
                              'Core_kernel.Std.Sequence.t ->
                              f:('-> bool T(M).t) -> bool T(M).t
                            val count :
                              'Core_kernel.Std.Sequence.t ->
                              f:('-> bool T(M).t) -> Monoid.Int.t T(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'Core_kernel.Std.Sequence.t ->
                              f:('-> 'T(M).t) -> 'T(M).t
                            val find :
                              'Core_kernel.Std.Sequence.t ->
                              f:('-> bool T(M).t) -> 'Option.t T(M).t
                            val find_map :
                              'Core_kernel.Std.Sequence.t ->
                              f:('-> 'Option.t T(M).t) ->
                              'Option.t T(M).t
                            val filter :
                              'Core_kernel.Std.Sequence.t ->
                              f:('-> bool T(M).t) ->
                              'Core_kernel.Std.Sequence.t T(M).t
                            val filter_map :
                              'Core_kernel.Std.Sequence.t ->
                              f:('-> 'Option.t T(M).t) ->
                              'Core_kernel.Std.Sequence.t T(M).t
                          end
                        val ( >=> ) :
                          ('-> 'T(M).t) ->
                          ('-> 'T(M).t) -> '-> 'T(M).t
                        val ( !! ) : '-> 'T(M).t
                        val ( !$ ) : ('-> 'b) -> 'T(M).t -> 'T(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          'T(M).t -> 'T(M).t -> 'T(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          'T(M).t ->
                          'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T(M).t ->
                          'T(M).t ->
                          'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                        val ( >>= ) :
                          'T(M).t -> ('-> 'T(M).t) -> 'T(M).t
                        val ( >>| ) : 'T(M).t -> ('-> 'b) -> 'T(M).t
                        module Monad_infix :
                          sig
                            val ( >>= ) :
                              'T(M).t -> ('-> 'T(M).t) -> 'T(M).t
                            val ( >>| ) :
                              'T(M).t -> ('-> 'b) -> 'T(M).t
                          end
                        val bind :
                          'T(M).t -> f:('-> 'T(M).t) -> 'T(M).t
                        val return : '-> 'T(M).t
                        val map : 'T(M).t -> f:('-> 'b) -> 'T(M).t
                        val join : 'T(M).t T(M).t -> 'T(M).t
                        val ignore_m : 'T(M).t -> Monoid.Unit.t T(M).t
                        val all : 'T(M).t list -> 'a list T(M).t
                        val all_ignore :
                          Monoid.Unit.t T(M).t list -> Monoid.Unit.t T(M).t
                        module Let_syntax :
                          sig
                            val return : '-> 'T(M).t
                            val ( >>= ) :
                              'T(M).t -> ('-> 'T(M).t) -> 'T(M).t
                            val ( >>| ) :
                              'T(M).t -> ('-> 'b) -> 'T(M).t
                            module Let_syntax :
                              sig
                                val return : '-> 'T(M).t
                                val bind :
                                  'T(M).t ->
                                  f:('-> 'T(M).t) -> 'T(M).t
                                val map :
                                  'T(M).t -> f:('-> 'b) -> 'T(M).t
                                val both :
                                  'T(M).t -> 'T(M).t -> ('a * 'b) T(M).t
                                module Open_on_rhs : sig  end
                              end
                          end
                        module Syntax :
                          sig
                            val ( >>= ) :
                              'T(M).t -> ('-> 'T(M).t) -> 'T(M).t
                            val ( >>| ) :
                              'T(M).t -> ('-> 'b) -> 'T(M).t
                            val ( >=> ) :
                              ('-> 'T(M).t) ->
                              ('-> 'T(M).t) -> '-> 'T(M).t
                            val ( !! ) : '-> 'T(M).t
                            val ( !$ ) : ('-> 'b) -> 'T(M).t -> 'T(M).t
                            val ( !$$ ) :
                              ('-> '-> 'c) ->
                              'T(M).t -> 'T(M).t -> 'T(M).t
                            val ( !$$$ ) :
                              ('-> '-> '-> 'd) ->
                              'T(M).t ->
                              'T(M).t -> 'T(M).t -> 'T(M).t
                            val ( !$$$$ ) :
                              ('-> '-> '-> '-> 'e) ->
                              'T(M).t ->
                              'T(M).t ->
                              'T(M).t -> 'T(M).t -> 'T(M).t
                            val ( !$$$$$ ) :
                              ('-> '-> '-> '-> '-> 'f) ->
                              'T(M).t ->
                              'T(M).t ->
                              'T(M).t ->
                              'T(M).t -> 'T(M).t -> 'T(M).t
                          end
                        type 'a error = Core_kernel.Std.Error.t
                        val fail : Core_kernel.Std.Error.t -> 'T(M).t
                        val catch :
                          'T(M).t ->
                          (Core_kernel.Std.Error.t -> 'T(M).t) -> 'T(M).t
                        val failf :
                          ('a, Format.formatter, Monoid.Unit.t,
                           Monoid.Unit.t -> 'T(M).t)
                          Core_kernel.Std.format4 -> 'a
                      end
                  type 'a t = 'Core_kernel.Std.Or_error.t
                  type 'a m = 'a
                  type 'a e = 'a t
                  val lift : '-> 'a e
                  val run : 'a e -> 'a e
                  val void : 'a e -> Monoid.Unit.t e
                  val sequence : Monoid.Unit.t e list -> Monoid.Unit.t e
                  val forever : 'a e -> 'b e
                  module Fn :
                    sig
                      val id : '-> 'a e
                      val ignore : 'a e -> Monoid.Unit.t e
                      val nothing : Monoid.Unit.t -> Monoid.Unit.t e
                      val non : ('-> bool e) -> '-> bool e
                      val apply_n_times :
                        n:Monoid.Int.t -> ('-> 'a e) -> '-> 'a e
                      val compose :
                        ('-> 'c e) -> ('-> 'b e) -> '-> 'c e
                    end
                  module Pair :
                    sig
                      val fst : ('a * 'b) e -> 'a e
                      val snd : ('a * 'b) e -> 'b e
                    end
                  module Triple :
                    sig
                      val fst : ('a * 'b * 'c) e -> 'a e
                      val snd : ('a * 'b * 'c) e -> 'b e
                      val trd : ('a * 'b * 'c) e -> 'c e
                    end
                  module Lift :
                    sig
                      val nullary : '-> 'a e
                      val unary : ('-> 'b) -> 'a e -> 'b e
                      val binary : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
                      val ternary :
                        ('-> '-> '-> 'd) ->
                        'a e -> 'b e -> 'c e -> 'd e
                      val quaternary :
                        ('-> '-> '-> '-> 'e) ->
                        'a e -> 'b e -> 'c e -> 'd e -> 'e e
                      val quinary :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
                    end
                  module Exn :
                    sig
                      val expect :
                        ?finally:(Monoid.Unit.t -> Monoid.Unit.t e) ->
                        f:(Monoid.Unit.t -> 'a e) ->
                        catch:(exn -> 'a e) -> 'a e
                    end
                  module Collection :
                    sig
                      module type S =
                        sig
                          type 'a t
                          val all : 'a e t -> 'a t e
                          val all_ignore : 'a e t -> Monoid.Unit.t e
                          val sequence : Monoid.Unit.t e t -> Monoid.Unit.t e
                          val map : 'a t -> f:('-> 'b e) -> 'b t e
                          val iter :
                            'a t ->
                            f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                          val fold :
                            'a t -> init:'-> f:('-> '-> 'b e) -> 'b e
                          val fold_left :
                            'a t -> init:'-> f:('-> '-> 'b e) -> 'b e
                          val fold_right :
                            'a t -> f:('-> '-> 'b e) -> init:'-> 'b e
                          val reduce :
                            'a t -> f:('-> '-> 'a e) -> 'Option.t e
                          val exists : 'a t -> f:('-> bool e) -> bool e
                          val for_all : 'a t -> f:('-> bool e) -> bool e
                          val count :
                            'a t -> f:('-> bool e) -> Monoid.Int.t e
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b t -> f:('-> 'a e) -> 'a e
                          val find :
                            'a t -> f:('-> bool e) -> 'Option.t e
                          val find_map :
                            'a t -> f:('-> 'Option.t e) -> 'Option.t e
                          val filter : 'a t -> f:('-> bool e) -> 'a t e
                          val filter_map :
                            'a t -> f:('-> 'Option.t e) -> 'b t e
                        end
                      module Eager :
                        functor (T : Collection.Eager->
                          sig
                            val all : 'a e T.t -> 'T.t e
                            val all_ignore : 'a e T.t -> Monoid.Unit.t e
                            val sequence :
                              Monoid.Unit.t e T.t -> Monoid.Unit.t e
                            val map : 'T.t -> f:('-> 'b e) -> 'T.t e
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b e) -> 'b e
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b e) -> 'b e
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b e) -> init:'-> 'b e
                            val reduce :
                              'T.t -> f:('-> '-> 'a e) -> 'Option.t e
                            val exists : 'T.t -> f:('-> bool e) -> bool e
                            val for_all :
                              'T.t -> f:('-> bool e) -> bool e
                            val count :
                              'T.t -> f:('-> bool e) -> Monoid.Int.t e
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a e) -> 'a e
                            val find :
                              'T.t -> f:('-> bool e) -> 'Option.t e
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t e) -> 'Option.t e
                            val filter :
                              'T.t -> f:('-> bool e) -> 'T.t e
                            val filter_map :
                              'T.t -> f:('-> 'Option.t e) -> 'T.t e
                          end
                      module Delay :
                        functor (T : Collection.Delay->
                          sig
                            val all : 'a e T.t -> 'T.t e
                            val all_ignore : 'a e T.t -> Monoid.Unit.t e
                            val sequence :
                              Monoid.Unit.t e T.t -> Monoid.Unit.t e
                            val map : 'T.t -> f:('-> 'b e) -> 'T.t e
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b e) -> 'b e
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b e) -> 'b e
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b e) -> init:'-> 'b e
                            val reduce :
                              'T.t -> f:('-> '-> 'a e) -> 'Option.t e
                            val exists : 'T.t -> f:('-> bool e) -> bool e
                            val for_all :
                              'T.t -> f:('-> bool e) -> bool e
                            val count :
                              'T.t -> f:('-> bool e) -> Monoid.Int.t e
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a e) -> 'a e
                            val find :
                              'T.t -> f:('-> bool e) -> 'Option.t e
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t e) -> 'Option.t e
                            val filter :
                              'T.t -> f:('-> bool e) -> 'T.t e
                            val filter_map :
                              'T.t -> f:('-> 'Option.t e) -> 'T.t e
                          end
                    end
                  module List :
                    sig
                      val all : 'a e list -> 'a list e
                      val all_ignore : 'a e list -> Monoid.Unit.t e
                      val sequence : Monoid.Unit.t e list -> Monoid.Unit.t e
                      val map : 'a list -> f:('-> 'b e) -> 'b list e
                      val iter :
                        'a list ->
                        f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                      val fold :
                        'a list -> init:'-> f:('-> '-> 'b e) -> 'b e
                      val fold_left :
                        'a list -> init:'-> f:('-> '-> 'b e) -> 'b e
                      val fold_right :
                        'a list -> f:('-> '-> 'b e) -> init:'-> 'b e
                      val reduce :
                        'a list -> f:('-> '-> 'a e) -> 'Option.t e
                      val exists : 'a list -> f:('-> bool e) -> bool e
                      val for_all : 'a list -> f:('-> bool e) -> bool e
                      val count :
                        'a list -> f:('-> bool e) -> Monoid.Int.t e
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b list -> f:('-> 'a e) -> 'a e
                      val find : 'a list -> f:('-> bool e) -> 'Option.t e
                      val find_map :
                        'a list -> f:('-> 'Option.t e) -> 'Option.t e
                      val filter : 'a list -> f:('-> bool e) -> 'a list e
                      val filter_map :
                        'a list -> f:('-> 'Option.t e) -> 'b list e
                    end
                  module Seq :
                    sig
                      val all :
                        'a e Core_kernel.Std.Sequence.t ->
                        'Core_kernel.Std.Sequence.t e
                      val all_ignore :
                        'a e Core_kernel.Std.Sequence.t -> Monoid.Unit.t e
                      val sequence :
                        Monoid.Unit.t e Core_kernel.Std.Sequence.t ->
                        Monoid.Unit.t e
                      val map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> 'b e) -> 'Core_kernel.Std.Sequence.t e
                      val iter :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                      val fold :
                        'Core_kernel.Std.Sequence.t ->
                        init:'-> f:('-> '-> 'b e) -> 'b e
                      val fold_left :
                        'Core_kernel.Std.Sequence.t ->
                        init:'-> f:('-> '-> 'b e) -> 'b e
                      val fold_right :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> '-> 'b e) -> init:'-> 'b e
                      val reduce :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> '-> 'a e) -> 'Option.t e
                      val exists :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool e) -> bool e
                      val for_all :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool e) -> bool e
                      val count :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool e) -> Monoid.Int.t e
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> 'a e) -> 'a e
                      val find :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool e) -> 'Option.t e
                      val find_map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> 'Option.t e) -> 'Option.t e
                      val filter :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool e) -> 'Core_kernel.Std.Sequence.t e
                      val filter_map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> 'Option.t e) ->
                        'Core_kernel.Std.Sequence.t e
                    end
                  val ( >=> ) : ('-> 'b e) -> ('-> 'c e) -> '-> 'c e
                  val ( !! ) : '-> 'a e
                  val ( !$ ) : ('-> 'b) -> 'a e -> 'b e
                  val ( !$$ ) : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a e -> 'b e -> 'c e -> 'd e -> 'e e
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
                  val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
                  val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
                  module Monad_infix :
                    sig
                      val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
                      val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
                    end
                  val bind : 'a e -> f:('-> 'b e) -> 'b e
                  val return : '-> 'a e
                  val map : 'a e -> f:('-> 'b) -> 'b e
                  val join : 'a e e -> 'a e
                  val ignore_m : 'a e -> Monoid.Unit.t e
                  val all : 'a e list -> 'a list e
                  val all_ignore : Monoid.Unit.t e list -> Monoid.Unit.t e
                  module Let_syntax :
                    sig
                      val return : '-> 'a e
                      val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
                      val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
                      module Let_syntax :
                        sig
                          val return : '-> 'a e
                          val bind : 'a e -> f:('-> 'b e) -> 'b e
                          val map : 'a e -> f:('-> 'b) -> 'b e
                          val both : 'a e -> 'b e -> ('a * 'b) e
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Syntax :
                    sig
                      val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
                      val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
                      val ( >=> ) :
                        ('-> 'b e) -> ('-> 'c e) -> '-> 'c e
                      val ( !! ) : '-> 'a e
                      val ( !$ ) : ('-> 'b) -> 'a e -> 'b e
                      val ( !$$ ) : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        'a e -> 'b e -> 'c e -> 'd e
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        'a e -> 'b e -> 'c e -> 'd e -> 'e e
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
                    end
                  type 'a error = Core_kernel.Std.Error.t
                  val fail : Core_kernel.Std.Error.t -> 'a e
                  val catch :
                    'a e -> (Core_kernel.Std.Error.t -> 'a e) -> 'a e
                  val failf :
                    ('a, Format.formatter, Monoid.Unit.t,
                     Monoid.Unit.t -> 'b e)
                    Core_kernel.Std.format4 -> 'a
                end
              module Exception :
                sig
                  type 'a t = ('a, exn) Core_kernel.Std.Result.t
                  type 'a m = 'a
                  type 'a e = ('a, exn) Core_kernel.Std.Result.t
                  val lift : '-> 'a t
                  val run : 'a t -> 'a e
                  val void : 'a t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
                  val forever : 'a t -> 'b t
                  module Fn :
                    sig
                      val id : '-> 'a t
                      val ignore : 'a t -> Monoid.Unit.t t
                      val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                      val non : ('-> bool t) -> '-> bool t
                      val apply_n_times :
                        n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                      val compose :
                        ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                    end
                  module Pair :
                    sig
                      val fst : ('a * 'b) t -> 'a t
                      val snd : ('a * 'b) t -> 'b t
                    end
                  module Triple :
                    sig
                      val fst : ('a * 'b * 'c) t -> 'a t
                      val snd : ('a * 'b * 'c) t -> 'b t
                      val trd : ('a * 'b * 'c) t -> 'c t
                    end
                  module Lift :
                    sig
                      val nullary : '-> 'a t
                      val unary : ('-> 'b) -> 'a t -> 'b t
                      val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ternary :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val quaternary :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val quinary :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                  module Exn :
                    sig
                      val expect :
                        ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                        f:(Monoid.Unit.t -> 'a t) ->
                        catch:(exn -> 'a t) -> 'a t
                    end
                  module Collection :
                    sig
                      module type S =
                        sig
                          type 'a t
                          val all : 'a t t -> 'a t t
                          val all_ignore : 'a t t -> Monoid.Unit.t t
                          val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                          val map : 'a t -> f:('-> 'b t) -> 'b t t
                          val iter :
                            'a t ->
                            f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                          val fold :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_left :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_right :
                            'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                          val reduce :
                            'a t -> f:('-> '-> 'a t) -> 'Option.t t
                          val exists : 'a t -> f:('-> bool t) -> bool t
                          val for_all : 'a t -> f:('-> bool t) -> bool t
                          val count :
                            'a t -> f:('-> bool t) -> Monoid.Int.t t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b t -> f:('-> 'a t) -> 'a t
                          val find :
                            'a t -> f:('-> bool t) -> 'Option.t t
                          val find_map :
                            'a t -> f:('-> 'Option.t t) -> 'Option.t t
                          val filter : 'a t -> f:('-> bool t) -> 'a t t
                          val filter_map :
                            'a t -> f:('-> 'Option.t t) -> 'b t t
                        end
                      module Eager :
                        functor (T : Collection.Eager->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'Option.t t
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t t) -> 'Option.t t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'Option.t t) -> 'T.t t
                          end
                      module Delay :
                        functor (T : Collection.Delay->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'Option.t t
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t t) -> 'Option.t t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'Option.t t) -> 'T.t t
                          end
                    end
                  module List :
                    sig
                      val all : 'a t list -> 'a list t
                      val all_ignore : 'a t list -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
                      val map : 'a list -> f:('-> 'b t) -> 'b list t
                      val iter :
                        'a list ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'a list -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'a list -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'a list -> f:('-> bool t) -> bool t
                      val for_all : 'a list -> f:('-> bool t) -> bool t
                      val count :
                        'a list -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b list -> f:('-> 'a t) -> 'a t
                      val find : 'a list -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'a list -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter : 'a list -> f:('-> bool t) -> 'a list t
                      val filter_map :
                        'a list -> f:('-> 'Option.t t) -> 'b list t
                    end
                  module Seq :
                    sig
                      val all :
                        'a t Core_kernel.Std.Sequence.t ->
                        'Core_kernel.Std.Sequence.t t
                      val all_ignore :
                        'a t Core_kernel.Std.Sequence.t -> Monoid.Unit.t t
                      val sequence :
                        Monoid.Unit.t t Core_kernel.Std.Sequence.t ->
                        Monoid.Unit.t t
                      val map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> 'b t) -> 'Core_kernel.Std.Sequence.t t
                      val iter :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'Core_kernel.Std.Sequence.t ->
                        init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'Core_kernel.Std.Sequence.t ->
                        init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> '-> 'a t) -> 'Option.t t
                      val exists :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> bool t
                      val for_all :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> bool t
                      val count :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> 'a t) -> 'a t
                      val find :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> 'Option.t t) -> 'Option.t t
                      val filter :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> 'Core_kernel.Std.Sequence.t t
                      val filter_map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> 'Option.t t) ->
                        'Core_kernel.Std.Sequence.t t
                    end
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Monad_infix :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                    end
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val return : '-> 'a t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val join : 'a t t -> 'a t
                  val ignore_m : 'a t -> Monoid.Unit.t t
                  val all : 'a t list -> 'a list t
                  val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      module Let_syntax :
                        sig
                          val return : '-> 'a t
                          val bind : 'a t -> f:('-> 'b t) -> 'b t
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val both : 'a t -> 'b t -> ('a * 'b) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Syntax :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      val ( >=> ) :
                        ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                      val ( !! ) : '-> 'a t
                      val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                      val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                  type 'a error = exn
                  val fail : exn -> 'a t
                  val catch : 'a t -> (exn -> 'a t) -> 'a t
                  module T :
                    functor (M : Monad->
                      sig
                        type 'a m = 'M.t
                        type 'a t =
                            ('a, exn) Core_kernel.Std.Result.t
                            Monads.Std.Monad.Result.Exception.T.m
                        type 'a e =
                            ('a, exn) Core_kernel.Std.Result.t
                            Monads.Std.Monad.Result.Exception.T.m
                      end
                  module Make :
                    functor (M : Monad->
                      sig
                        val lift : 'M.t -> 'T(M).t
                        val run : 'T(M).t -> 'T(M).e
                        val void : 'T(M).t -> Monoid.Unit.t T(M).t
                        val sequence :
                          Monoid.Unit.t T(M).t list -> Monoid.Unit.t T(M).t
                        val forever : 'T(M).t -> 'T(M).t
                        module Fn :
                          sig
                            val id : '-> 'T(M).t
                            val ignore : 'T(M).t -> Monoid.Unit.t T(M).t
                            val nothing :
                              Monoid.Unit.t -> Monoid.Unit.t T(M).t
                            val non :
                              ('-> bool T(M).t) -> '-> bool T(M).t
                            val apply_n_times :
                              n:Monoid.Int.t ->
                              ('-> 'T(M).t) -> '-> 'T(M).t
                            val compose :
                              ('-> 'T(M).t) ->
                              ('-> 'T(M).t) -> '-> 'T(M).t
                          end
                        module Pair :
                          sig
                            val fst : ('a * 'b) T(M).t -> 'T(M).t
                            val snd : ('a * 'b) T(M).t -> 'T(M).t
                          end
                        module Triple :
                          sig
                            val fst : ('a * 'b * 'c) T(M).t -> 'T(M).t
                            val snd : ('a * 'b * 'c) T(M).t -> 'T(M).t
                            val trd : ('a * 'b * 'c) T(M).t -> 'T(M).t
                          end
                        module Lift :
                          sig
                            val nullary : '-> 'T(M).t
                            val unary : ('-> 'b) -> 'T(M).t -> 'T(M).t
                            val binary :
                              ('-> '-> 'c) ->
                              'T(M).t -> 'T(M).t -> 'T(M).t
                            val ternary :
                              ('-> '-> '-> 'd) ->
                              'T(M).t ->
                              'T(M).t -> 'T(M).t -> 'T(M).t
                            val quaternary :
                              ('-> '-> '-> '-> 'e) ->
                              'T(M).t ->
                              'T(M).t ->
                              'T(M).t -> 'T(M).t -> 'T(M).t
                            val quinary :
                              ('-> '-> '-> '-> '-> 'f) ->
                              'T(M).t ->
                              'T(M).t ->
                              'T(M).t ->
                              'T(M).t -> 'T(M).t -> 'T(M).t
                          end
                        module Exn :
                          sig
                            val expect :
                              ?finally:(Monoid.Unit.t -> Monoid.Unit.t T(M).t) ->
                              f:(Monoid.Unit.t -> 'T(M).t) ->
                              catch:(exn -> 'T(M).t) -> 'T(M).t
                          end
                        module Collection :
                          sig
                            module type S =
                              sig
                                type 'a t
                                val all : 'T(M).t t -> 'a t T(M).t
                                val all_ignore :
                                  'T(M).t t -> Monoid.Unit.t T(M).t
                                val sequence :
                                  Monoid.Unit.t T(M).t t ->
                                  Monoid.Unit.t T(M).t
                                val map :
                                  'a t -> f:('-> 'T(M).t) -> 'b t T(M).t
                                val iter :
                                  'a t ->
                                  f:('-> Monoid.Unit.t T(M).t) ->
                                  Monoid.Unit.t T(M).t
                                val fold :
                                  'a t ->
                                  init:'->
                                  f:('-> '-> 'T(M).t) -> 'T(M).t
                                val fold_left :
                                  'a t ->
                                  init:'->
                                  f:('-> '-> 'T(M).t) -> 'T(M).t
                                val fold_right :
                                  'a t ->
                                  f:('-> '-> 'T(M).t) ->
                                  init:'-> 'T(M).t
                                val reduce :
                                  'a t ->
                                  f:('-> '-> 'T(M).t) ->
                                  'Option.t T(M).t
                                val exists :
                                  'a t ->
                                  f:('-> bool T(M).t) -> bool T(M).t
                                val for_all :
                                  'a t ->
                                  f:('-> bool T(M).t) -> bool T(M).t
                                val count :
                                  'a t ->
                                  f:('-> bool T(M).t) ->
                                  Monoid.Int.t T(M).t
                                val map_reduce :
                                  (module Monoid.S with type t = 'a) ->
                                  'b t -> f:('-> 'T(M).t) -> 'T(M).t
                                val find :
                                  'a t ->
                                  f:('-> bool T(M).t) -> 'Option.t T(M).t
                                val find_map :
                                  'a t ->
                                  f:('-> 'Option.t T(M).t) ->
                                  'Option.t T(M).t
                                val filter :
                                  'a t ->
                                  f:('-> bool T(M).t) -> 'a t T(M).t
                                val filter_map :
                                  'a t ->
                                  f:('-> 'Option.t T(M).t) -> 'b t T(M).t
                              end
                            module Eager :
                              functor (T : Collection.Eager->
                                sig
                                  val all : 'T(M).t T.t -> 'T.t T(M).t
                                  val all_ignore :
                                    'T(M).t T.t -> Monoid.Unit.t T(M).t
                                  val sequence :
                                    Monoid.Unit.t T(M).t T.t ->
                                    Monoid.Unit.t T(M).t
                                  val map :
                                    'T.t ->
                                    f:('-> 'T(M).t) -> 'T.t T(M).t
                                  val iter :
                                    'T.t ->
                                    f:('-> Monoid.Unit.t T(M).t) ->
                                    Monoid.Unit.t T(M).t
                                  val fold :
                                    'T.t ->
                                    init:'->
                                    f:('-> '-> 'T(M).t) -> 'T(M).t
                                  val fold_left :
                                    'T.t ->
                                    init:'->
                                    f:('-> '-> 'T(M).t) -> 'T(M).t
                                  val fold_right :
                                    'T.t ->
                                    f:('-> '-> 'T(M).t) ->
                                    init:'-> 'T(M).t
                                  val reduce :
                                    'T.t ->
                                    f:('-> '-> 'T(M).t) ->
                                    'Option.t T(M).t
                                  val exists :
                                    'T.t ->
                                    f:('-> bool T(M).t) -> bool T(M).t
                                  val for_all :
                                    'T.t ->
                                    f:('-> bool T(M).t) -> bool T(M).t
                                  val count :
                                    'T.t ->
                                    f:('-> bool T(M).t) ->
                                    Monoid.Int.t T(M).t
                                  val map_reduce :
                                    (module Monoid.S with type t = 'a) ->
                                    'T.t ->
                                    f:('-> 'T(M).t) -> 'T(M).t
                                  val find :
                                    'T.t ->
                                    f:('-> bool T(M).t) ->
                                    'Option.t T(M).t
                                  val find_map :
                                    'T.t ->
                                    f:('-> 'Option.t T(M).t) ->
                                    'Option.t T(M).t
                                  val filter :
                                    'T.t ->
                                    f:('-> bool T(M).t) -> 'T.t T(M).t
                                  val filter_map :
                                    'T.t ->
                                    f:('-> 'Option.t T(M).t) ->
                                    'T.t T(M).t
                                end
                            module Delay :
                              functor (T : Collection.Delay->
                                sig
                                  val all : 'T(M).t T.t -> 'T.t T(M).t
                                  val all_ignore :
                                    'T(M).t T.t -> Monoid.Unit.t T(M).t
                                  val sequence :
                                    Monoid.Unit.t T(M).t T.t ->
                                    Monoid.Unit.t T(M).t
                                  val map :
                                    'T.t ->
                                    f:('-> 'T(M).t) -> 'T.t T(M).t
                                  val iter :
                                    'T.t ->
                                    f:('-> Monoid.Unit.t T(M).t) ->
                                    Monoid.Unit.t T(M).t
                                  val fold :
                                    'T.t ->
                                    init:'->
                                    f:('-> '-> 'T(M).t) -> 'T(M).t
                                  val fold_left :
                                    'T.t ->
                                    init:'->
                                    f:('-> '-> 'T(M).t) -> 'T(M).t
                                  val fold_right :
                                    'T.t ->
                                    f:('-> '-> 'T(M).t) ->
                                    init:'-> 'T(M).t
                                  val reduce :
                                    'T.t ->
                                    f:('-> '-> 'T(M).t) ->
                                    'Option.t T(M).t
                                  val exists :
                                    'T.t ->
                                    f:('-> bool T(M).t) -> bool T(M).t
                                  val for_all :
                                    'T.t ->
                                    f:('-> bool T(M).t) -> bool T(M).t
                                  val count :
                                    'T.t ->
                                    f:('-> bool T(M).t) ->
                                    Monoid.Int.t T(M).t
                                  val map_reduce :
                                    (module Monoid.S with type t = 'a) ->
                                    'T.t ->
                                    f:('-> 'T(M).t) -> 'T(M).t
                                  val find :
                                    'T.t ->
                                    f:('-> bool T(M).t) ->
                                    'Option.t T(M).t
                                  val find_map :
                                    'T.t ->
                                    f:('-> 'Option.t T(M).t) ->
                                    'Option.t T(M).t
                                  val filter :
                                    'T.t ->
                                    f:('-> bool T(M).t) -> 'T.t T(M).t
                                  val filter_map :
                                    'T.t ->
                                    f:('-> 'Option.t T(M).t) ->
                                    'T.t T(M).t
                                end
                          end
                        module List :
                          sig
                            val all : 'T(M).t list -> 'a list T(M).t
                            val all_ignore :
                              'T(M).t list -> Monoid.Unit.t T(M).t
                            val sequence :
                              Monoid.Unit.t T(M).t list ->
                              Monoid.Unit.t T(M).t
                            val map :
                              'a list ->
                              f:('-> 'T(M).t) -> 'b list T(M).t
                            val iter :
                              'a list ->
                              f:('-> Monoid.Unit.t T(M).t) ->
                              Monoid.Unit.t T(M).t
                            val fold :
                              'a list ->
                              init:'->
                              f:('-> '-> 'T(M).t) -> 'T(M).t
                            val fold_left :
                              'a list ->
                              init:'->
                              f:('-> '-> 'T(M).t) -> 'T(M).t
                            val fold_right :
                              'a list ->
                              f:('-> '-> 'T(M).t) ->
                              init:'-> 'T(M).t
                            val reduce :
                              'a list ->
                              f:('-> '-> 'T(M).t) -> 'Option.t T(M).t
                            val exists :
                              'a list -> f:('-> bool T(M).t) -> bool T(M).t
                            val for_all :
                              'a list -> f:('-> bool T(M).t) -> bool T(M).t
                            val count :
                              'a list ->
                              f:('-> bool T(M).t) -> Monoid.Int.t T(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b list -> f:('-> 'T(M).t) -> 'T(M).t
                            val find :
                              'a list ->
                              f:('-> bool T(M).t) -> 'Option.t T(M).t
                            val find_map :
                              'a list ->
                              f:('-> 'Option.t T(M).t) ->
                              'Option.t T(M).t
                            val filter :
                              'a list ->
                              f:('-> bool T(M).t) -> 'a list T(M).t
                            val filter_map :
                              'a list ->
                              f:('-> 'Option.t T(M).t) -> 'b list T(M).t
                          end
                        module Seq :
                          sig
                            val all :
                              'T(M).t Core_kernel.Std.Sequence.t ->
                              'Core_kernel.Std.Sequence.t T(M).t
                            val all_ignore :
                              'T(M).t Core_kernel.Std.Sequence.t ->
                              Monoid.Unit.t T(M).t
                            val sequence :
                              Monoid.Unit.t T(M).t Core_kernel.Std.Sequence.t ->
                              Monoid.Unit.t T(M).t
                            val map :
                              'Core_kernel.Std.Sequence.t ->
                              f:('-> 'T(M).t) ->
                              'Core_kernel.Std.Sequence.t T(M).t
                            val iter :
                              'Core_kernel.Std.Sequence.t ->
                              f:('-> Monoid.Unit.t T(M).t) ->
                              Monoid.Unit.t T(M).t
                            val fold :
                              'Core_kernel.Std.Sequence.t ->
                              init:'->
                              f:('-> '-> 'T(M).t) -> 'T(M).t
                            val fold_left :
                              'Core_kernel.Std.Sequence.t ->
                              init:'->
                              f:('-> '-> 'T(M).t) -> 'T(M).t
                            val fold_right :
                              'Core_kernel.Std.Sequence.t ->
                              f:('-> '-> 'T(M).t) ->
                              init:'-> 'T(M).t
                            val reduce :
                              'Core_kernel.Std.Sequence.t ->
                              f:('-> '-> 'T(M).t) -> 'Option.t T(M).t
                            val exists :
                              'Core_kernel.Std.Sequence.t ->
                              f:('-> bool T(M).t) -> bool T(M).t
                            val for_all :
                              'Core_kernel.Std.Sequence.t ->
                              f:('-> bool T(M).t) -> bool T(M).t
                            val count :
                              'Core_kernel.Std.Sequence.t ->
                              f:('-> bool T(M).t) -> Monoid.Int.t T(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'Core_kernel.Std.Sequence.t ->
                              f:('-> 'T(M).t) -> 'T(M).t
                            val find :
                              'Core_kernel.Std.Sequence.t ->
                              f:('-> bool T(M).t) -> 'Option.t T(M).t
                            val find_map :
                              'Core_kernel.Std.Sequence.t ->
                              f:('-> 'Option.t T(M).t) ->
                              'Option.t T(M).t
                            val filter :
                              'Core_kernel.Std.Sequence.t ->
                              f:('-> bool T(M).t) ->
                              'Core_kernel.Std.Sequence.t T(M).t
                            val filter_map :
                              'Core_kernel.Std.Sequence.t ->
                              f:('-> 'Option.t T(M).t) ->
                              'Core_kernel.Std.Sequence.t T(M).t
                          end
                        val ( >=> ) :
                          ('-> 'T(M).t) ->
                          ('-> 'T(M).t) -> '-> 'T(M).t
                        val ( !! ) : '-> 'T(M).t
                        val ( !$ ) : ('-> 'b) -> 'T(M).t -> 'T(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          'T(M).t -> 'T(M).t -> 'T(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          'T(M).t ->
                          'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T(M).t ->
                          'T(M).t ->
                          'T(M).t -> 'T(M).t -> 'T(M).t -> 'T(M).t
                        val ( >>= ) :
                          'T(M).t -> ('-> 'T(M).t) -> 'T(M).t
                        val ( >>| ) : 'T(M).t -> ('-> 'b) -> 'T(M).t
                        module Monad_infix :
                          sig
                            val ( >>= ) :
                              'T(M).t -> ('-> 'T(M).t) -> 'T(M).t
                            val ( >>| ) :
                              'T(M).t -> ('-> 'b) -> 'T(M).t
                          end
                        val bind :
                          'T(M).t -> f:('-> 'T(M).t) -> 'T(M).t
                        val return : '-> 'T(M).t
                        val map : 'T(M).t -> f:('-> 'b) -> 'T(M).t
                        val join : 'T(M).t T(M).t -> 'T(M).t
                        val ignore_m : 'T(M).t -> Monoid.Unit.t T(M).t
                        val all : 'T(M).t list -> 'a list T(M).t
                        val all_ignore :
                          Monoid.Unit.t T(M).t list -> Monoid.Unit.t T(M).t
                        module Let_syntax :
                          sig
                            val return : '-> 'T(M).t
                            val ( >>= ) :
                              'T(M).t -> ('-> 'T(M).t) -> 'T(M).t
                            val ( >>| ) :
                              'T(M).t -> ('-> 'b) -> 'T(M).t
                            module Let_syntax :
                              sig
                                val return : '-> 'T(M).t
                                val bind :
                                  'T(M).t ->
                                  f:('-> 'T(M).t) -> 'T(M).t
                                val map :
                                  'T(M).t -> f:('-> 'b) -> 'T(M).t
                                val both :
                                  'T(M).t -> 'T(M).t -> ('a * 'b) T(M).t
                                module Open_on_rhs : sig  end
                              end
                          end
                        module Syntax :
                          sig
                            val ( >>= ) :
                              'T(M).t -> ('-> 'T(M).t) -> 'T(M).t
                            val ( >>| ) :
                              'T(M).t -> ('-> 'b) -> 'T(M).t
                            val ( >=> ) :
                              ('-> 'T(M).t) ->
                              ('-> 'T(M).t) -> '-> 'T(M).t
                            val ( !! ) : '-> 'T(M).t
                            val ( !$ ) : ('-> 'b) -> 'T(M).t -> 'T(M).t
                            val ( !$$ ) :
                              ('-> '-> 'c) ->
                              'T(M).t -> 'T(M).t -> 'T(M).t
                            val ( !$$$ ) :
                              ('-> '-> '-> 'd) ->
                              'T(M).t ->
                              'T(M).t -> 'T(M).t -> 'T(M).t
                            val ( !$$$$ ) :
                              ('-> '-> '-> '-> 'e) ->
                              'T(M).t ->
                              'T(M).t ->
                              'T(M).t -> 'T(M).t -> 'T(M).t
                            val ( !$$$$$ ) :
                              ('-> '-> '-> '-> '-> 'f) ->
                              'T(M).t ->
                              'T(M).t ->
                              'T(M).t ->
                              'T(M).t -> 'T(M).t -> 'T(M).t
                          end
                        type 'a error = exn
                        val fail : exn -> 'T(M).t
                        val catch :
                          'T(M).t -> (exn -> 'T(M).t) -> 'T(M).t
                      end
                end
            end
          module List :
            sig
              module type S =
                sig
                  type 'a t
                  type 'a m
                  type 'a e
                  val lift : 'a m -> 'a t
                  val run : 'a t -> 'a e
                  val void : 'a t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
                  val forever : 'a t -> 'b t
                  module Fn :
                    sig
                      val id : '-> 'a t
                      val ignore : 'a t -> Monoid.Unit.t t
                      val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                      val non : ('-> bool t) -> '-> bool t
                      val apply_n_times :
                        n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                      val compose :
                        ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                    end
                  module Pair :
                    sig
                      val fst : ('a * 'b) t -> 'a t
                      val snd : ('a * 'b) t -> 'b t
                    end
                  module Triple :
                    sig
                      val fst : ('a * 'b * 'c) t -> 'a t
                      val snd : ('a * 'b * 'c) t -> 'b t
                      val trd : ('a * 'b * 'c) t -> 'c t
                    end
                  module Lift :
                    sig
                      val nullary : '-> 'a t
                      val unary : ('-> 'b) -> 'a t -> 'b t
                      val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ternary :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val quaternary :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val quinary :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                  module Exn :
                    sig
                      val expect :
                        ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                        f:(Monoid.Unit.t -> 'a t) ->
                        catch:(exn -> 'a t) -> 'a t
                    end
                  module Collection :
                    sig
                      module type S =
                        sig
                          type 'a t
                          val all : 'a t t -> 'a t t
                          val all_ignore : 'a t t -> Monoid.Unit.t t
                          val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                          val map : 'a t -> f:('-> 'b t) -> 'b t t
                          val iter :
                            'a t ->
                            f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                          val fold :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_left :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_right :
                            'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                          val reduce :
                            'a t -> f:('-> '-> 'a t) -> 'Option.t t
                          val exists : 'a t -> f:('-> bool t) -> bool t
                          val for_all : 'a t -> f:('-> bool t) -> bool t
                          val count :
                            'a t -> f:('-> bool t) -> Monoid.Int.t t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b t -> f:('-> 'a t) -> 'a t
                          val find :
                            'a t -> f:('-> bool t) -> 'Option.t t
                          val find_map :
                            'a t -> f:('-> 'Option.t t) -> 'Option.t t
                          val filter : 'a t -> f:('-> bool t) -> 'a t t
                          val filter_map :
                            'a t -> f:('-> 'Option.t t) -> 'b t t
                        end
                      module Eager :
                        functor (T : Collection.Eager->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'Option.t t
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t t) -> 'Option.t t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'Option.t t) -> 'T.t t
                          end
                      module Delay :
                        functor (T : Collection.Delay->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'Option.t t
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t t) -> 'Option.t t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'Option.t t) -> 'T.t t
                          end
                    end
                  module List :
                    sig
                      val all : 'a t list -> 'a list t
                      val all_ignore : 'a t list -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t list -> Monoid.Unit.t t
                      val map : 'a list -> f:('-> 'b t) -> 'b list t
                      val iter :
                        'a list ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'a list -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'a list -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'a list -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'a list -> f:('-> bool t) -> bool t
                      val for_all : 'a list -> f:('-> bool t) -> bool t
                      val count :
                        'a list -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b list -> f:('-> 'a t) -> 'a t
                      val find : 'a list -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'a list -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter : 'a list -> f:('-> bool t) -> 'a list t
                      val filter_map :
                        'a list -> f:('-> 'Option.t t) -> 'b list t
                    end
                  module Seq :
                    sig
                      val all :
                        'a t Core_kernel.Std.Sequence.t ->
                        'Core_kernel.Std.Sequence.t t
                      val all_ignore :
                        'a t Core_kernel.Std.Sequence.t -> Monoid.Unit.t t
                      val sequence :
                        Monoid.Unit.t t Core_kernel.Std.Sequence.t ->
                        Monoid.Unit.t t
                      val map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> 'b t) -> 'Core_kernel.Std.Sequence.t t
                      val iter :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'Core_kernel.Std.Sequence.t ->
                        init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'Core_kernel.Std.Sequence.t ->
                        init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> '-> 'a t) -> 'Option.t t
                      val exists :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> bool t
                      val for_all :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> bool t
                      val count :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> 'a t) -> 'a t
                      val find :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> 'Option.t t) -> 'Option.t t
                      val filter :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> 'Core_kernel.Std.Sequence.t t
                      val filter_map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> 'Option.t t) ->
                        'Core_kernel.Std.Sequence.t t
                    end
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Monad_infix :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                    end
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val return : '-> 'a t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val join : 'a t t -> 'a t
                  val ignore_m : 'a t -> Monoid.Unit.t t
                  val all : 'a t list -> 'a list t
                  val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      module Let_syntax :
                        sig
                          val return : '-> 'a t
                          val bind : 'a t -> f:('-> 'b t) -> 'b t
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val both : 'a t -> 'b t -> ('a * 'b) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Syntax :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      val ( >=> ) :
                        ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                      val ( !! ) : '-> 'a t
                      val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                      val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                  val pure : '-> 'a t
                  val accept : '-> 'a t
                  val reject : Monoid.Unit.t -> 'a t
                  val guard : bool -> Monoid.Unit.t t
                  val on : bool -> Monoid.Unit.t t -> Monoid.Unit.t t
                  val unless : bool -> Monoid.Unit.t t -> Monoid.Unit.t t
                  val zero : Monoid.Unit.t -> 'a t
                  val plus : 'a t -> 'a t -> 'a t
                end
              module type S2 =
                sig
                  type ('a, 'e) t
                  type ('a, 'e) m
                  type ('a, 'e) e
                  val lift : ('a, 'e) m -> ('a, 'e) t
                  val run : ('a, 'e) t -> ('a, 'e) e
                  val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                  val forever : ('a, 'e) t -> ('b, 'e) t
                  module Fn :
                    sig
                      val id : '-> ('a, 'e) t
                      val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                      val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                      val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                      val apply_n_times :
                        n:Monoid.Int.t ->
                        ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                      val compose :
                        ('-> ('c, 'e) t) ->
                        ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                    end
                  module Pair :
                    sig
                      val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                      val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                    end
                  module Triple :
                    sig
                      val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                      val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                      val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                    end
                  module Lift :
                    sig
                      val nullary : '-> ('a, 'e) t
                      val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                      val binary :
                        ('-> '-> 'c) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                      val ternary :
                        ('-> '-> '-> 'd) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                      val quaternary :
                        ('-> '-> '-> '-> 'e) ->
                        ('a, 's) t ->
                        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                      val quinary :
                        ('-> '-> '-> '-> '-> 'f) ->
                        ('a, 's) t ->
                        ('b, 's) t ->
                        ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                    end
                  module Exn :
                    sig
                      val expect :
                        ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                        f:(Monoid.Unit.t -> ('a, 's) t) ->
                        catch:(exn -> ('a, 's) t) -> ('a, 's) t
                    end
                  module Collection :
                    sig
                      module type S =
                        sig
                          type 'a t
                          val all : ('a, 'e) t t -> ('a t, 'e) t
                          val all_ignore :
                            ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
                          val sequence :
                            (Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
                          val map :
                            'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                          val iter :
                            'a t ->
                            f:('-> (Monoid.Unit.t, 'e) t) ->
                            (Monoid.Unit.t, 'e) t
                          val fold :
                            'a t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_left :
                            'a t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_right :
                            'a t ->
                            f:('-> '-> ('b, 'e) t) ->
                            init:'-> ('b, 'e) t
                          val reduce :
                            'a t ->
                            f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                          val exists :
                            'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val for_all :
                            'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val count :
                            'a t ->
                            f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                          val find :
                            'a t ->
                            f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                          val find_map :
                            'a t ->
                            f:('-> ('Option.t, 'e) t) ->
                            ('Option.t, 'e) t
                          val filter :
                            'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                          val filter_map :
                            'a t ->
                            f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                        end
                      module Eager :
                        functor (T : Collection.Eager->
                          sig
                            val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                            val all_ignore :
                              ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                            val sequence :
                              (Monoid.Unit.t, 'e) t T.t ->
                              (Monoid.Unit.t, 'e) t
                            val map :
                              'T.t ->
                              f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                            val iter :
                              'T.t ->
                              f:('-> (Monoid.Unit.t, 'e) t) ->
                              (Monoid.Unit.t, 'e) t
                            val fold :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_left :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> ('b, 'e) t) ->
                              init:'-> ('b, 'e) t
                            val reduce :
                              'T.t ->
                              f:('-> '-> ('a, 'e) t) ->
                              ('Option.t, 'e) t
                            val exists :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val for_all :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val count :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                            val find :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                            val find_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) ->
                              ('Option.t, 'e) t
                            val filter :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                            val filter_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                          end
                      module Delay :
                        functor (T : Collection.Delay->
                          sig
                            val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                            val all_ignore :
                              ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                            val sequence :
                              (Monoid.Unit.t, 'e) t T.t ->
                              (Monoid.Unit.t, 'e) t
                            val map :
                              'T.t ->
                              f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                            val iter :
                              'T.t ->
                              f:('-> (Monoid.Unit.t, 'e) t) ->
                              (Monoid.Unit.t, 'e) t
                            val fold :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_left :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> ('b, 'e) t) ->
                              init:'-> ('b, 'e) t
                            val reduce :
                              'T.t ->
                              f:('-> '-> ('a, 'e) t) ->
                              ('Option.t, 'e) t
                            val exists :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val for_all :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val count :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                            val find :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                            val find_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) ->
                              ('Option.t, 'e) t
                            val filter :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                            val filter_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                          end
                    end
                  module List :
                    sig
                      val all : ('a, 'e) t list -> ('a list, 'e) t
                      val all_ignore :
                        ('a, 'e) t list -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                      val map :
                        'a list -> f:('-> ('b, 'e) t) -> ('b list, 'e) t
                      val iter :
                        'a list ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'a list ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'a list ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'a list ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'a list ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'a list -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'a list ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b list -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'a list ->
                        f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'a list ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'a list -> f:('-> (bool, 'e) t) -> ('a list, 'e) t
                      val filter_map :
                        'a list ->
                        f:('-> ('Option.t, 'e) t) -> ('b list, 'e) t
                    end
                  module Seq :
                    sig
                      val all :
                        ('a, 'e) t Core_kernel.Std.Sequence.t ->
                        ('Core_kernel.Std.Sequence.t, 'e) t
                      val all_ignore :
                        ('a, 'e) t Core_kernel.Std.Sequence.t ->
                        (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t Core_kernel.Std.Sequence.t ->
                        (Monoid.Unit.t, 'e) t
                      val map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> ('b, 'e) t) ->
                        ('Core_kernel.Std.Sequence.t, 'e) t
                      val iter :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'Core_kernel.Std.Sequence.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'Core_kernel.Std.Sequence.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> (bool, 'e) t) ->
                        ('Core_kernel.Std.Sequence.t, 'e) t
                      val filter_map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> ('Option.t, 'e) t) ->
                        ('Core_kernel.Std.Sequence.t, 'e) t
                    end
                  val ( >=> ) :
                    ('-> ('b, 'e) t) ->
                    ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                  val ( !! ) : '-> ('a, 'e) t
                  val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      module Let_syntax :
                        sig
                          val return : '-> ('a, 'b) t
                          val bind :
                            ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                          val both :
                            ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Monad_infix :
                    sig
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                    end
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val return : '-> ('a, 'b) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                  val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val all : ('a, 'e) t list -> ('a list, 'e) t
                  val all_ignore :
                    (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                  module Syntax :
                    sig
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      val ( >=> ) :
                        ('-> ('b, 'e) t) ->
                        ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                      val ( !! ) : '-> ('a, 'e) t
                      val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                      val ( !$$ ) :
                        ('-> '-> 'c) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        ('a, 's) t ->
                        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        ('a, 's) t ->
                        ('b, 's) t ->
                        ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                    end
                  val pure : '-> ('a, 'e) t
                  val accept : '-> ('a, 'e) t
                  val reject : Monoid.Unit.t -> ('a, 'e) t
                  val guard : bool -> (Monoid.Unit.t, 'e) t
                  val on :
                    bool -> (Monoid.Unit.t, 'e) t -> (Monoid.Unit.t, 'e) t
                  val unless :
                    bool -> (Monoid.Unit.t, 'e) t -> (Monoid.Unit.t, 'e) t
                  val zero : Monoid.Unit.t -> ('a, 'e) t
                  val plus : ('a, 'e) t -> ('a, 'e) t -> ('a, 'e) t
                end
              type 'a t = 'a list
              type 'a m = 'a
              type 'a e = 'a t
              val lift : '-> 'a e
              val run : 'a e -> 'a e
              val void : 'a e -> Monoid.Unit.t e
              val sequence : Monoid.Unit.t e e -> Monoid.Unit.t e
              val forever : 'a e -> 'b e
              module Fn :
                sig
                  val id : '-> 'a e
                  val ignore : 'a e -> Monoid.Unit.t e
                  val nothing : Monoid.Unit.t -> Monoid.Unit.t e
                  val non : ('-> bool e) -> '-> bool e
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> 'a e) -> '-> 'a e
                  val compose : ('-> 'c e) -> ('-> 'b e) -> '-> 'c e
                end
              module Pair :
                sig
                  val fst : ('a * 'b) e -> 'a e
                  val snd : ('a * 'b) e -> 'b e
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c) e -> 'a e
                  val snd : ('a * 'b * 'c) e -> 'b e
                  val trd : ('a * 'b * 'c) e -> 'c e
                end
              module Lift :
                sig
                  val nullary : '-> 'a e
                  val unary : ('-> 'b) -> 'a e -> 'b e
                  val binary : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
                  val ternary :
                    ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    'a e -> 'b e -> 'c e -> 'd e -> 'e e
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> Monoid.Unit.t e) ->
                    f:(Monoid.Unit.t -> 'a e) -> catch:(exn -> 'a e) -> 'a e
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : 'a e t -> 'a t e
                      val all_ignore : 'a e t -> Monoid.Unit.t e
                      val sequence : Monoid.Unit.t e t -> Monoid.Unit.t e
                      val map : 'a t -> f:('-> 'b e) -> 'b t e
                      val iter :
                        'a t -> f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                      val fold :
                        'a t -> init:'-> f:('-> '-> 'b e) -> 'b e
                      val fold_left :
                        'a t -> init:'-> f:('-> '-> 'b e) -> 'b e
                      val fold_right :
                        'a t -> f:('-> '-> 'b e) -> init:'-> 'b e
                      val reduce :
                        'a t -> f:('-> '-> 'a e) -> 'Option.t e
                      val exists : 'a t -> f:('-> bool e) -> bool e
                      val for_all : 'a t -> f:('-> bool e) -> bool e
                      val count : 'a t -> f:('-> bool e) -> Monoid.Int.t e
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> 'a e) -> 'a e
                      val find : 'a t -> f:('-> bool e) -> 'Option.t e
                      val find_map :
                        'a t -> f:('-> 'Option.t e) -> 'Option.t e
                      val filter : 'a t -> f:('-> bool e) -> 'a t e
                      val filter_map :
                        'a t -> f:('-> 'Option.t e) -> 'b t e
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : 'a e T.t -> 'T.t e
                        val all_ignore : 'a e T.t -> Monoid.Unit.t e
                        val sequence : Monoid.Unit.t e T.t -> Monoid.Unit.t e
                        val map : 'T.t -> f:('-> 'b e) -> 'T.t e
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                        val fold_right :
                          'T.t -> f:('-> '-> 'b e) -> init:'-> 'b e
                        val reduce :
                          'T.t -> f:('-> '-> 'a e) -> 'Option.t e
                        val exists : 'T.t -> f:('-> bool e) -> bool e
                        val for_all : 'T.t -> f:('-> bool e) -> bool e
                        val count :
                          'T.t -> f:('-> bool e) -> Monoid.Int.t e
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a e) -> 'a e
                        val find :
                          'T.t -> f:('-> bool e) -> 'Option.t e
                        val find_map :
                          'T.t -> f:('-> 'Option.t e) -> 'Option.t e
                        val filter : 'T.t -> f:('-> bool e) -> 'T.t e
                        val filter_map :
                          'T.t -> f:('-> 'Option.t e) -> 'T.t e
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : 'a e T.t -> 'T.t e
                        val all_ignore : 'a e T.t -> Monoid.Unit.t e
                        val sequence : Monoid.Unit.t e T.t -> Monoid.Unit.t e
                        val map : 'T.t -> f:('-> 'b e) -> 'T.t e
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                        val fold_right :
                          'T.t -> f:('-> '-> 'b e) -> init:'-> 'b e
                        val reduce :
                          'T.t -> f:('-> '-> 'a e) -> 'Option.t e
                        val exists : 'T.t -> f:('-> bool e) -> bool e
                        val for_all : 'T.t -> f:('-> bool e) -> bool e
                        val count :
                          'T.t -> f:('-> bool e) -> Monoid.Int.t e
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a e) -> 'a e
                        val find :
                          'T.t -> f:('-> bool e) -> 'Option.t e
                        val find_map :
                          'T.t -> f:('-> 'Option.t e) -> 'Option.t e
                        val filter : 'T.t -> f:('-> bool e) -> 'T.t e
                        val filter_map :
                          'T.t -> f:('-> 'Option.t e) -> 'T.t e
                      end
                end
              module List :
                sig
                  val all : 'a e e -> 'a e e
                  val all_ignore : 'a e e -> Monoid.Unit.t e
                  val sequence : Monoid.Unit.t e e -> Monoid.Unit.t e
                  val map : 'a e -> f:('-> 'b e) -> 'b e e
                  val iter :
                    'a e -> f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                  val fold : 'a e -> init:'-> f:('-> '-> 'b e) -> 'b e
                  val fold_left :
                    'a e -> init:'-> f:('-> '-> 'b e) -> 'b e
                  val fold_right :
                    'a e -> f:('-> '-> 'b e) -> init:'-> 'b e
                  val reduce : 'a e -> f:('-> '-> 'a e) -> 'Option.t e
                  val exists : 'a e -> f:('-> bool e) -> bool e
                  val for_all : 'a e -> f:('-> bool e) -> bool e
                  val count : 'a e -> f:('-> bool e) -> Monoid.Int.t e
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b e -> f:('-> 'a e) -> 'a e
                  val find : 'a e -> f:('-> bool e) -> 'Option.t e
                  val find_map :
                    'a e -> f:('-> 'Option.t e) -> 'Option.t e
                  val filter : 'a e -> f:('-> bool e) -> 'a e e
                  val filter_map : 'a e -> f:('-> 'Option.t e) -> 'b e e
                end
              module Seq :
                sig
                  val all :
                    'a e Core_kernel.Std.Sequence.t ->
                    'Core_kernel.Std.Sequence.t e
                  val all_ignore :
                    'a e Core_kernel.Std.Sequence.t -> Monoid.Unit.t e
                  val sequence :
                    Monoid.Unit.t e Core_kernel.Std.Sequence.t ->
                    Monoid.Unit.t e
                  val map :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> 'b e) -> 'Core_kernel.Std.Sequence.t e
                  val iter :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                  val fold :
                    'Core_kernel.Std.Sequence.t ->
                    init:'-> f:('-> '-> 'b e) -> 'b e
                  val fold_left :
                    'Core_kernel.Std.Sequence.t ->
                    init:'-> f:('-> '-> 'b e) -> 'b e
                  val fold_right :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> '-> 'b e) -> init:'-> 'b e
                  val reduce :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> '-> 'a e) -> 'Option.t e
                  val exists :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> bool e) -> bool e
                  val for_all :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> bool e) -> bool e
                  val count :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> bool e) -> Monoid.Int.t e
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Core_kernel.Std.Sequence.t -> f:('-> 'a e) -> 'a e
                  val find :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> bool e) -> 'Option.t e
                  val find_map :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> 'Option.t e) -> 'Option.t e
                  val filter :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> bool e) -> 'Core_kernel.Std.Sequence.t e
                  val filter_map :
                    'Core_kernel.Std.Sequence.t ->
                    f:('-> 'Option.t e) ->
                    'Core_kernel.Std.Sequence.t e
                end
              val ( >=> ) : ('-> 'b e) -> ('-> 'c e) -> '-> 'c e
              val ( !! ) : '-> 'a e
              val ( !$ ) : ('-> 'b) -> 'a e -> 'b e
              val ( !$$ ) : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a e -> 'b e -> 'c e -> 'd e -> 'e e
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
              val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
              val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
              module Monad_infix :
                sig
                  val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
                  val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
                end
              val bind : 'a e -> f:('-> 'b e) -> 'b e
              val return : '-> 'a e
              val map : 'a e -> f:('-> 'b) -> 'b e
              val join : 'a e e -> 'a e
              val ignore_m : 'a e -> Monoid.Unit.t e
              val all : 'a e e -> 'a e e
              val all_ignore : Monoid.Unit.t e e -> Monoid.Unit.t e
              module Let_syntax :
                sig
                  val return : '-> 'a e
                  val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
                  val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
                  module Let_syntax :
                    sig
                      val return : '-> 'a e
                      val bind : 'a e -> f:('-> 'b e) -> 'b e
                      val map : 'a e -> f:('-> 'b) -> 'b e
                      val both : 'a e -> 'b e -> ('a * 'b) e
                      module Open_on_rhs : sig  end
                    end
                end
              module Syntax :
                sig
                  val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
                  val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
                  val ( >=> ) : ('-> 'b e) -> ('-> 'c e) -> '-> 'c e
                  val ( !! ) : '-> 'a e
                  val ( !$ ) : ('-> 'b) -> 'a e -> 'b e
                  val ( !$$ ) : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a e -> 'b e -> 'c e -> 'd e -> 'e e
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
                end
              val pure : '-> 'a e
              val accept : '-> 'a e
              val reject : Monoid.Unit.t -> 'a e
              val guard : bool -> Monoid.Unit.t e
              val on : bool -> Monoid.Unit.t e -> Monoid.Unit.t e
              val unless : bool -> Monoid.Unit.t e -> Monoid.Unit.t e
              val zero : Monoid.Unit.t -> 'a e
              val plus : 'a e -> 'a e -> 'a e
              module T1 :
                functor (M : Core_kernel.Std.T1->
                  sig
                    type 'a t = 'a list M.t
                    type 'a m = 'M.t
                    type 'a e = 'Monads.Std.Monad.List.T1.t
                  end
              module Make :
                functor (M : Monad->
                  sig
                    val lift : 'M.t -> 'T1(M).t
                    val run : 'T1(M).t -> 'Monads.Std.Monad.List.T1.t
                    val void : 'T1(M).t -> Monoid.Unit.t T1(M).t
                    val sequence :
                      Monoid.Unit.t T1(M).t e -> Monoid.Unit.t T1(M).t
                    val forever : 'T1(M).t -> 'T1(M).t
                    module Fn :
                      sig
                        val id : '-> 'T1(M).t
                        val ignore : 'T1(M).t -> Monoid.Unit.t T1(M).t
                        val nothing : Monoid.Unit.t -> Monoid.Unit.t T1(M).t
                        val non : ('-> bool T1(M).t) -> '-> bool T1(M).t
                        val apply_n_times :
                          n:Monoid.Int.t ->
                          ('-> 'T1(M).t) -> '-> 'T1(M).t
                        val compose :
                          ('-> 'T1(M).t) ->
                          ('-> 'T1(M).t) -> '-> 'T1(M).t
                      end
                    module Pair :
                      sig
                        val fst : ('a * 'b) T1(M).t -> 'T1(M).t
                        val snd : ('a * 'b) T1(M).t -> 'T1(M).t
                      end
                    module Triple :
                      sig
                        val fst : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                        val snd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                        val trd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                      end
                    module Lift :
                      sig
                        val nullary : '-> 'T1(M).t
                        val unary : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                        val binary :
                          ('-> '-> 'c) ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val ternary :
                          ('-> '-> '-> 'd) ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val quaternary :
                          ('-> '-> '-> '-> 'e) ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val quinary :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                      end
                    module Exn :
                      sig
                        val expect :
                          ?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(M).t) ->
                          f:(Monoid.Unit.t -> 'T1(M).t) ->
                          catch:(exn -> 'T1(M).t) -> 'T1(M).t
                      end
                    module Collection :
                      sig
                        module type S =
                          sig
                            type 'a t
                            val all : 'T1(M).t t -> 'a t T1(M).t
                            val all_ignore :
                              'T1(M).t t -> Monoid.Unit.t T1(M).t
                            val sequence :
                              Monoid.Unit.t T1(M).t t ->
                              Monoid.Unit.t T1(M).t
                            val map :
                              'a t -> f:('-> 'T1(M).t) -> 'b t T1(M).t
                            val iter :
                              'a t ->
                              f:('-> Monoid.Unit.t T1(M).t) ->
                              Monoid.Unit.t T1(M).t
                            val fold :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T1(M).t) -> 'T1(M).t
                            val fold_left :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T1(M).t) -> 'T1(M).t
                            val fold_right :
                              'a t ->
                              f:('-> '-> 'T1(M).t) ->
                              init:'-> 'T1(M).t
                            val reduce :
                              'a t ->
                              f:('-> '-> 'T1(M).t) ->
                              'Option.t T1(M).t
                            val exists :
                              'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                            val for_all :
                              'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                            val count :
                              'a t ->
                              f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b t -> f:('-> 'T1(M).t) -> 'T1(M).t
                            val find :
                              'a t ->
                              f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                            val find_map :
                              'a t ->
                              f:('-> 'Option.t T1(M).t) ->
                              'Option.t T1(M).t
                            val filter :
                              'a t -> f:('-> bool T1(M).t) -> 'a t T1(M).t
                            val filter_map :
                              'a t ->
                              f:('-> 'Option.t T1(M).t) -> 'b t T1(M).t
                          end
                        module Eager :
                          functor (T : Collection.Eager->
                            sig
                              val all : 'T1(M).t T.t -> 'T.t T1(M).t
                              val all_ignore :
                                'T1(M).t T.t -> Monoid.Unit.t T1(M).t
                              val sequence :
                                Monoid.Unit.t T1(M).t T.t ->
                                Monoid.Unit.t T1(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T1(M).t) -> 'T.t T1(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T1(M).t) ->
                                Monoid.Unit.t T1(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(M).t) -> 'T1(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(M).t) -> 'T1(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T1(M).t) ->
                                init:'-> 'T1(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T1(M).t) ->
                                'Option.t T1(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T1(M).t) -> bool T1(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T1(M).t) -> bool T1(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T1(M).t) ->
                                Monoid.Int.t T1(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'Option.t T1(M).t) ->
                                'Option.t T1(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T1(M).t) -> 'T.t T1(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'Option.t T1(M).t) ->
                                'T.t T1(M).t
                            end
                        module Delay :
                          functor (T : Collection.Delay->
                            sig
                              val all : 'T1(M).t T.t -> 'T.t T1(M).t
                              val all_ignore :
                                'T1(M).t T.t -> Monoid.Unit.t T1(M).t
                              val sequence :
                                Monoid.Unit.t T1(M).t T.t ->
                                Monoid.Unit.t T1(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T1(M).t) -> 'T.t T1(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T1(M).t) ->
                                Monoid.Unit.t T1(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(M).t) -> 'T1(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(M).t) -> 'T1(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T1(M).t) ->
                                init:'-> 'T1(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T1(M).t) ->
                                'Option.t T1(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T1(M).t) -> bool T1(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T1(M).t) -> bool T1(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T1(M).t) ->
                                Monoid.Int.t T1(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'Option.t T1(M).t) ->
                                'Option.t T1(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T1(M).t) -> 'T.t T1(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'Option.t T1(M).t) ->
                                'T.t T1(M).t
                            end
                      end
                    module List :
                      sig
                        val all : 'T1(M).t e -> 'a e T1(M).t
                        val all_ignore :
                          'T1(M).t e -> Monoid.Unit.t T1(M).t
                        val sequence :
                          Monoid.Unit.t T1(M).t e -> Monoid.Unit.t T1(M).t
                        val map :
                          'a e -> f:('-> 'T1(M).t) -> 'b e T1(M).t
                        val iter :
                          'a e ->
                          f:('-> Monoid.Unit.t T1(M).t) ->
                          Monoid.Unit.t T1(M).t
                        val fold :
                          'a e ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_left :
                          'a e ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_right :
                          'a e ->
                          f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                        val reduce :
                          'a e ->
                          f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                        val exists :
                          'a e -> f:('-> bool T1(M).t) -> bool T1(M).t
                        val for_all :
                          'a e -> f:('-> bool T1(M).t) -> bool T1(M).t
                        val count :
                          'a e ->
                          f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b e -> f:('-> 'T1(M).t) -> 'T1(M).t
                        val find :
                          'a e ->
                          f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                        val find_map :
                          'a e ->
                          f:('-> 'Option.t T1(M).t) ->
                          'Option.t T1(M).t
                        val filter :
                          'a e -> f:('-> bool T1(M).t) -> 'a e T1(M).t
                        val filter_map :
                          'a e ->
                          f:('-> 'Option.t T1(M).t) -> 'b e T1(M).t
                      end
                    module Seq :
                      sig
                        val all :
                          'T1(M).t Core_kernel.Std.Sequence.t ->
                          'Core_kernel.Std.Sequence.t T1(M).t
                        val all_ignore :
                          'T1(M).t Core_kernel.Std.Sequence.t ->
                          Monoid.Unit.t T1(M).t
                        val sequence :
                          Monoid.Unit.t T1(M).t Core_kernel.Std.Sequence.t ->
                          Monoid.Unit.t T1(M).t
                        val map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'T1(M).t) ->
                          'Core_kernel.Std.Sequence.t T1(M).t
                        val iter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> Monoid.Unit.t T1(M).t) ->
                          Monoid.Unit.t T1(M).t
                        val fold :
                          'Core_kernel.Std.Sequence.t ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_left :
                          'Core_kernel.Std.Sequence.t ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_right :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                        val reduce :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                        val exists :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(M).t) -> bool T1(M).t
                        val for_all :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(M).t) -> bool T1(M).t
                        val count :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'T1(M).t) -> 'T1(M).t
                        val find :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                        val find_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'Option.t T1(M).t) ->
                          'Option.t T1(M).t
                        val filter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(M).t) ->
                          'Core_kernel.Std.Sequence.t T1(M).t
                        val filter_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'Option.t T1(M).t) ->
                          'Core_kernel.Std.Sequence.t T1(M).t
                      end
                    val ( >=> ) :
                      ('-> 'T1(M).t) ->
                      ('-> 'T1(M).t) -> '-> 'T1(M).t
                    val ( !! ) : '-> 'T1(M).t
                    val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(M).t ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( >>= ) :
                      'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                    val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                        val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                      end
                    val bind :
                      'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
                    val return : '-> 'T1(M).t
                    val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                    val join : 'T1(M).t T1(M).t -> 'T1(M).t
                    val ignore_m : 'T1(M).t -> Monoid.Unit.t T1(M).t
                    val all : 'T1(M).t e -> 'a e T1(M).t
                    val all_ignore :
                      Monoid.Unit.t T1(M).t e -> Monoid.Unit.t T1(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T1(M).t
                        val ( >>= ) :
                          'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                        val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                        module Let_syntax :
                          sig
                            val return : '-> 'T1(M).t
                            val bind :
                              'T1(M).t ->
                              f:('-> 'T1(M).t) -> 'T1(M).t
                            val map :
                              'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                            val both :
                              'T1(M).t -> 'T1(M).t -> ('a * 'b) T1(M).t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Syntax :
                      sig
                        val ( >>= ) :
                          'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                        val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                        val ( >=> ) :
                          ('-> 'T1(M).t) ->
                          ('-> 'T1(M).t) -> '-> 'T1(M).t
                        val ( !! ) : '-> 'T1(M).t
                        val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                      end
                    val pure : '-> 'T1(M).t
                    val accept : '-> 'T1(M).t
                    val reject : Monoid.Unit.t -> 'T1(M).t
                    val guard : bool -> Monoid.Unit.t T1(M).t
                    val on :
                      bool -> Monoid.Unit.t T1(M).t -> Monoid.Unit.t T1(M).t
                    val unless :
                      bool -> Monoid.Unit.t T1(M).t -> Monoid.Unit.t T1(M).t
                    val zero : Monoid.Unit.t -> 'T1(M).t
                    val plus : 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                  end
              module T2 :
                functor (M : Core_kernel.Std.T2->
                  sig
                    type ('a, 'e) t = ('a list, 'e) M.t
                    type ('a, 'e) m = ('a, 'e) M.t
                    type ('a, 'e) e = ('a, 'e) Monads.Std.Monad.List.T2.t
                  end
              module Make2 :
                functor (M : Monad2->
                  sig
                    val lift : ('a, 'e) M.t -> ('a, 'e) T2(M).t
                    val run :
                      ('a, 'e) T2(M).t -> ('a, 'e) Monads.Std.Monad.List.T2.t
                    val void :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t e ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    module Fn :
                      sig
                        val id : '-> ('a, 'e) T2(M).t
                        val ignore :
                          ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                        val nothing :
                          Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
                        val non :
                          ('-> (bool, 'e) T2(M).t) ->
                          '-> (bool, 'e) T2(M).t
                        val apply_n_times :
                          n:Monoid.Int.t ->
                          ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                        val compose :
                          ('-> ('c, 'e) T2(M).t) ->
                          ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                      end
                    module Pair :
                      sig
                        val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                        val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
                      end
                    module Triple :
                      sig
                        val fst :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                        val snd :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val trd :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
                      end
                    module Lift :
                      sig
                        val nullary : '-> ('a, 'e) T2(M).t
                        val unary :
                          ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val binary :
                          ('-> '-> 'c) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                        val ternary :
                          ('-> '-> '-> 'd) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t ->
                          ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                        val quaternary :
                          ('-> '-> '-> '-> 'e) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                        val quinary :
                          ('-> '-> '-> '-> '-> 'f) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t ->
                          ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                      end
                    module Exn :
                      sig
                        val expect :
                          ?finally:(Monoid.Unit.t ->
                                    (Monoid.Unit.t, 's) T2(M).t) ->
                          f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
                          catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
                      end
                    module Collection :
                      sig
                        module type S =
                          sig
                            type 'a t
                            val all :
                              ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                            val all_ignore :
                              ('a, 'e) T2(M).t t ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val sequence :
                              (Monoid.Unit.t, 'e) T2(M).t t ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val map :
                              'a t ->
                              f:('-> ('b, 'e) T2(M).t) ->
                              ('b t, 'e) T2(M).t
                            val iter :
                              'a t ->
                              f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val fold :
                              'a t ->
                              init:'->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              ('b, 'e) T2(M).t
                            val fold_left :
                              'a t ->
                              init:'->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              ('b, 'e) T2(M).t
                            val fold_right :
                              'a t ->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              init:'-> ('b, 'e) T2(M).t
                            val reduce :
                              'a t ->
                              f:('-> '-> ('a, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val exists :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (bool, 'e) T2(M).t
                            val for_all :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (bool, 'e) T2(M).t
                            val count :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (Monoid.Int.t, 'e) T2(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b t ->
                              f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                            val find :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val find_map :
                              'a t ->
                              f:('-> ('Option.t, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val filter :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              ('a t, 'e) T2(M).t
                            val filter_map :
                              'a t ->
                              f:('-> ('Option.t, 'e) T2(M).t) ->
                              ('b t, 'e) T2(M).t
                          end
                        module Eager :
                          functor (T : Collection.Eager->
                            sig
                              val all :
                                ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                              val all_ignore :
                                ('a, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val sequence :
                                (Monoid.Unit.t, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val map :
                                'T.t ->
                                f:('-> ('b, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val iter :
                                'T.t ->
                                f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                init:'-> ('b, 'e) T2(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> ('a, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val exists :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val for_all :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val count :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (Monoid.Int.t, 'e) T2(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> ('a, 'e) T2(M).t) ->
                                ('a, 'e) T2(M).t
                              val find :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val find_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val filter :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                            end
                        module Delay :
                          functor (T : Collection.Delay->
                            sig
                              val all :
                                ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                              val all_ignore :
                                ('a, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val sequence :
                                (Monoid.Unit.t, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val map :
                                'T.t ->
                                f:('-> ('b, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val iter :
                                'T.t ->
                                f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                init:'-> ('b, 'e) T2(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> ('a, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val exists :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val for_all :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val count :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (Monoid.Int.t, 'e) T2(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> ('a, 'e) T2(M).t) ->
                                ('a, 'e) T2(M).t
                              val find :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val find_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val filter :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                            end
                      end
                    module List :
                      sig
                        val all : ('a, 'e) T2(M).t e -> ('a e, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t e -> (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t e ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'a e ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b e, 'e) T2(M).t
                        val iter :
                          'a e ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'a e ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'a e ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'a e ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'a e ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'a e ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'a e ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'a e ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b e ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'a e ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'a e ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'a e ->
                          f:('-> (bool, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
                        val filter_map :
                          'a e ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('b e, 'e) T2(M).t
                      end
                    module Seq :
                      sig
                        val all :
                          ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t
                          Core_kernel.Std.Sequence.t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('b, 'e) T2(M).t) ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                        val iter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'Core_kernel.Std.Sequence.t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'Core_kernel.Std.Sequence.t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                        val filter_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                      end
                    val ( >=> ) :
                      ('-> ('b, 'e) T2(M).t) ->
                      ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                    val ( !! ) : '-> ('a, 'e) T2(M).t
                    val ( !$ ) :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) T2(M).t
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                        module Let_syntax :
                          sig
                            val return : '-> ('a, 'b) T2(M).t
                            val bind :
                              ('a, 'e) T2(M).t ->
                              f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                            val map :
                              ('a, 'e) T2(M).t ->
                              f:('-> 'b) -> ('b, 'e) T2(M).t
                            val both :
                              ('a, 'e) T2(M).t ->
                              ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                      end
                    val bind :
                      ('a, 'e) T2(M).t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val return : '-> ('a, 'b) T2(M).t
                    val map :
                      ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                    val join :
                      (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val ignore_m :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val all : ('a, 'e) T2(M).t e -> ('a e, 'e) T2(M).t
                    val all_ignore :
                      (Monoid.Unit.t, 'e) T2(M).t e ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    module Syntax :
                      sig
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                        val ( >=> ) :
                          ('-> ('b, 'e) T2(M).t) ->
                          ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                        val ( !! ) : '-> ('a, 'e) T2(M).t
                        val ( !$ ) :
                          ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t ->
                          ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t ->
                          ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                      end
                    val pure : '-> ('a, 'e) T2(M).t
                    val accept : '-> ('a, 'e) T2(M).t
                    val reject : Monoid.Unit.t -> ('a, 'e) T2(M).t
                    val guard : bool -> (Monoid.Unit.t, 'e) T2(M).t
                    val on :
                      bool ->
                      (Monoid.Unit.t, 'e) T2(M).t ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val unless :
                      bool ->
                      (Monoid.Unit.t, 'e) T2(M).t ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val zero : Monoid.Unit.t -> ('a, 'e) T2(M).t
                    val plus :
                      ('a, 'e) T2(M).t ->
                      ('a, 'e) T2(M).t -> ('a, 'e) T2(M).t
                  end
            end
          module Seq :
            sig
              module type S =
                sig
                  type 'a t
                  type 'a m
                  type 'a e
                  val lift : 'a m -> 'a t
                  val run : 'a t -> 'a e
                  val void : 'a t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
                  val forever : 'a t -> 'b t
                  module Fn :
                    sig
                      val id : '-> 'a t
                      val ignore : 'a t -> Monoid.Unit.t t
                      val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                      val non : ('-> bool t) -> '-> bool t
                      val apply_n_times :
                        n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                      val compose :
                        ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                    end
                  module Pair :
                    sig
                      val fst : ('a * 'b) t -> 'a t
                      val snd : ('a * 'b) t -> 'b t
                    end
                  module Triple :
                    sig
                      val fst : ('a * 'b * 'c) t -> 'a t
                      val snd : ('a * 'b * 'c) t -> 'b t
                      val trd : ('a * 'b * 'c) t -> 'c t
                    end
                  module Lift :
                    sig
                      val nullary : '-> 'a t
                      val unary : ('-> 'b) -> 'a t -> 'b t
                      val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ternary :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val quaternary :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val quinary :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                  module Exn :
                    sig
                      val expect :
                        ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                        f:(Monoid.Unit.t -> 'a t) ->
                        catch:(exn -> 'a t) -> 'a t
                    end
                  module Collection :
                    sig
                      module type S =
                        sig
                          type 'a t
                          val all : 'a t t -> 'a t t
                          val all_ignore : 'a t t -> Monoid.Unit.t t
                          val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                          val map : 'a t -> f:('-> 'b t) -> 'b t t
                          val iter :
                            'a t ->
                            f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                          val fold :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_left :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_right :
                            'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                          val reduce :
                            'a t -> f:('-> '-> 'a t) -> 'Option.t t
                          val exists : 'a t -> f:('-> bool t) -> bool t
                          val for_all : 'a t -> f:('-> bool t) -> bool t
                          val count :
                            'a t -> f:('-> bool t) -> Monoid.Int.t t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b t -> f:('-> 'a t) -> 'a t
                          val find :
                            'a t -> f:('-> bool t) -> 'Option.t t
                          val find_map :
                            'a t -> f:('-> 'Option.t t) -> 'Option.t t
                          val filter : 'a t -> f:('-> bool t) -> 'a t t
                          val filter_map :
                            'a t -> f:('-> 'Option.t t) -> 'b t t
                        end
                      module Eager :
                        functor (T : Collection.Eager->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'Option.t t
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t t) -> 'Option.t t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'Option.t t) -> 'T.t t
                          end
                      module Delay :
                        functor (T : Collection.Delay->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'Option.t t
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t t) -> 'Option.t t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'Option.t t) -> 'T.t t
                          end
                    end
                  module List :
                    sig
                      val all : 'a t List.t -> 'List.t t
                      val all_ignore : 'a t List.t -> Monoid.Unit.t t
                      val sequence :
                        Monoid.Unit.t t List.t -> Monoid.Unit.t t
                      val map : 'List.t -> f:('-> 'b t) -> 'List.t t
                      val iter :
                        'List.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'List.t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'List.t -> f:('-> bool t) -> bool t
                      val for_all : 'List.t -> f:('-> bool t) -> bool t
                      val count :
                        'List.t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'List.t -> f:('-> 'a t) -> 'a t
                      val find :
                        'List.t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'List.t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter :
                        'List.t -> f:('-> bool t) -> 'List.t t
                      val filter_map :
                        'List.t -> f:('-> 'Option.t t) -> 'List.t t
                    end
                  module Seq :
                    sig
                      val all :
                        'a t Core_kernel.Std.Sequence.t ->
                        'Core_kernel.Std.Sequence.t t
                      val all_ignore :
                        'a t Core_kernel.Std.Sequence.t -> Monoid.Unit.t t
                      val sequence :
                        Monoid.Unit.t t Core_kernel.Std.Sequence.t ->
                        Monoid.Unit.t t
                      val map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> 'b t) -> 'Core_kernel.Std.Sequence.t t
                      val iter :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'Core_kernel.Std.Sequence.t ->
                        init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'Core_kernel.Std.Sequence.t ->
                        init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> '-> 'a t) -> 'Option.t t
                      val exists :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> bool t
                      val for_all :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> bool t
                      val count :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> 'a t) -> 'a t
                      val find :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> 'Option.t t) -> 'Option.t t
                      val filter :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> bool t) -> 'Core_kernel.Std.Sequence.t t
                      val filter_map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> 'Option.t t) ->
                        'Core_kernel.Std.Sequence.t t
                    end
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Monad_infix :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                    end
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val return : '-> 'a t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val join : 'a t t -> 'a t
                  val ignore_m : 'a t -> Monoid.Unit.t t
                  val all : 'a t list -> 'a list t
                  val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      module Let_syntax :
                        sig
                          val return : '-> 'a t
                          val bind : 'a t -> f:('-> 'b t) -> 'b t
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val both : 'a t -> 'b t -> ('a * 'b) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Syntax :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      val ( >=> ) :
                        ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                      val ( !! ) : '-> 'a t
                      val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                      val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                  val pure : '-> 'a t
                  val accept : '-> 'a t
                  val reject : Monoid.Unit.t -> 'a t
                  val guard : bool -> Monoid.Unit.t t
                  val on : bool -> Monoid.Unit.t t -> Monoid.Unit.t t
                  val unless : bool -> Monoid.Unit.t t -> Monoid.Unit.t t
                  val zero : Monoid.Unit.t -> 'a t
                  val plus : 'a t -> 'a t -> 'a t
                end
              module type S2 =
                sig
                  type ('a, 'e) t
                  type ('a, 'e) m
                  type ('a, 'e) e
                  val lift : ('a, 'e) m -> ('a, 'e) t
                  val run : ('a, 'e) t -> ('a, 'e) e
                  val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val forever : ('a, 'e) t -> ('b, 'e) t
                  module Fn :
                    sig
                      val id : '-> ('a, 'e) t
                      val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                      val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                      val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                      val apply_n_times :
                        n:Monoid.Int.t ->
                        ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                      val compose :
                        ('-> ('c, 'e) t) ->
                        ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                    end
                  module Pair :
                    sig
                      val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                      val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                    end
                  module Triple :
                    sig
                      val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                      val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                      val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                    end
                  module Lift :
                    sig
                      val nullary : '-> ('a, 'e) t
                      val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                      val binary :
                        ('-> '-> 'c) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                      val ternary :
                        ('-> '-> '-> 'd) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                      val quaternary :
                        ('-> '-> '-> '-> 'e) ->
                        ('a, 's) t ->
                        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                      val quinary :
                        ('-> '-> '-> '-> '-> 'f) ->
                        ('a, 's) t ->
                        ('b, 's) t ->
                        ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                    end
                  module Exn :
                    sig
                      val expect :
                        ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                        f:(Monoid.Unit.t -> ('a, 's) t) ->
                        catch:(exn -> ('a, 's) t) -> ('a, 's) t
                    end
                  module Collection :
                    sig
                      module type S =
                        sig
                          type 'a t
                          val all : ('a, 'e) t t -> ('a t, 'e) t
                          val all_ignore :
                            ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
                          val sequence :
                            (Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
                          val map :
                            'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                          val iter :
                            'a t ->
                            f:('-> (Monoid.Unit.t, 'e) t) ->
                            (Monoid.Unit.t, 'e) t
                          val fold :
                            'a t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_left :
                            'a t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_right :
                            'a t ->
                            f:('-> '-> ('b, 'e) t) ->
                            init:'-> ('b, 'e) t
                          val reduce :
                            'a t ->
                            f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                          val exists :
                            'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val for_all :
                            'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val count :
                            'a t ->
                            f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                          val find :
                            'a t ->
                            f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                          val find_map :
                            'a t ->
                            f:('-> ('Option.t, 'e) t) ->
                            ('Option.t, 'e) t
                          val filter :
                            'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                          val filter_map :
                            'a t ->
                            f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                        end
                      module Eager :
                        functor (T : Collection.Eager->
                          sig
                            val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                            val all_ignore :
                              ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                            val sequence :
                              (Monoid.Unit.t, 'e) t T.t ->
                              (Monoid.Unit.t, 'e) t
                            val map :
                              'T.t ->
                              f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                            val iter :
                              'T.t ->
                              f:('-> (Monoid.Unit.t, 'e) t) ->
                              (Monoid.Unit.t, 'e) t
                            val fold :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_left :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> ('b, 'e) t) ->
                              init:'-> ('b, 'e) t
                            val reduce :
                              'T.t ->
                              f:('-> '-> ('a, 'e) t) ->
                              ('Option.t, 'e) t
                            val exists :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val for_all :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val count :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                            val find :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                            val find_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) ->
                              ('Option.t, 'e) t
                            val filter :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                            val filter_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                          end
                      module Delay :
                        functor (T : Collection.Delay->
                          sig
                            val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                            val all_ignore :
                              ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                            val sequence :
                              (Monoid.Unit.t, 'e) t T.t ->
                              (Monoid.Unit.t, 'e) t
                            val map :
                              'T.t ->
                              f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                            val iter :
                              'T.t ->
                              f:('-> (Monoid.Unit.t, 'e) t) ->
                              (Monoid.Unit.t, 'e) t
                            val fold :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_left :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> ('b, 'e) t) ->
                              init:'-> ('b, 'e) t
                            val reduce :
                              'T.t ->
                              f:('-> '-> ('a, 'e) t) ->
                              ('Option.t, 'e) t
                            val exists :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val for_all :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val count :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                            val find :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                            val find_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) ->
                              ('Option.t, 'e) t
                            val filter :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                            val filter_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                          end
                    end
                  module List :
                    sig
                      val all : ('a, 'e) t List.t -> ('List.t, 'e) t
                      val all_ignore :
                        ('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                      val map :
                        'List.t ->
                        f:('-> ('b, 'e) t) -> ('List.t, 'e) t
                      val iter :
                        'List.t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'List.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'List.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'List.t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'List.t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'List.t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'List.t ->
                        f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'List.t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'List.t ->
                        f:('-> (bool, 'e) t) -> ('List.t, 'e) t
                      val filter_map :
                        'List.t ->
                        f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
                    end
                  module Seq :
                    sig
                      val all :
                        ('a, 'e) t Core_kernel.Std.Sequence.t ->
                        ('Core_kernel.Std.Sequence.t, 'e) t
                      val all_ignore :
                        ('a, 'e) t Core_kernel.Std.Sequence.t ->
                        (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t Core_kernel.Std.Sequence.t ->
                        (Monoid.Unit.t, 'e) t
                      val map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> ('b, 'e) t) ->
                        ('Core_kernel.Std.Sequence.t, 'e) t
                      val iter :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'Core_kernel.Std.Sequence.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'Core_kernel.Std.Sequence.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> (bool, 'e) t) ->
                        ('Core_kernel.Std.Sequence.t, 'e) t
                      val filter_map :
                        'Core_kernel.Std.Sequence.t ->
                        f:('-> ('Option.t, 'e) t) ->
                        ('Core_kernel.Std.Sequence.t, 'e) t
                    end
                  val ( >=> ) :
                    ('-> ('b, 'e) t) ->
                    ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                  val ( !! ) : '-> ('a, 'e) t
                  val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      module Let_syntax :
                        sig
                          val return : '-> ('a, 'b) t
                          val bind :
                            ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                          val both :
                            ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Monad_infix :
                    sig
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                    end
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val return : '-> ('a, 'b) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                  val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val all : ('a, 'e) t list -> ('a list, 'e) t
                  val all_ignore :
                    (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                  module Syntax :
                    sig
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      val ( >=> ) :
                        ('-> ('b, 'e) t) ->
                        ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                      val ( !! ) : '-> ('a, 'e) t
                      val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                      val ( !$$ ) :
                        ('-> '-> 'c) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        ('a, 's) t ->
                        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        ('a, 's) t ->
                        ('b, 's) t ->
                        ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                    end
                  val pure : '-> ('a, 'e) t
                  val accept : '-> ('a, 'e) t
                  val reject : Monoid.Unit.t -> ('a, 'e) t
                  val guard : bool -> (Monoid.Unit.t, 'e) t
                  val on :
                    bool -> (Monoid.Unit.t, 'e) t -> (Monoid.Unit.t, 'e) t
                  val unless :
                    bool -> (Monoid.Unit.t, 'e) t -> (Monoid.Unit.t, 'e) t
                  val zero : Monoid.Unit.t -> ('a, 'e) t
                  val plus : ('a, 'e) t -> ('a, 'e) t -> ('a, 'e) t
                end
              type 'a t = 'Core_kernel.Std.Sequence.t
              type 'a m = 'a
              type 'a e = 'a t
              val lift : '-> 'a e
              val run : 'a e -> 'a e
              val void : 'a e -> Monoid.Unit.t e
              val sequence : Monoid.Unit.t e List.t -> Monoid.Unit.t e
              val forever : 'a e -> 'b e
              module Fn :
                sig
                  val id : '-> 'a e
                  val ignore : 'a e -> Monoid.Unit.t e
                  val nothing : Monoid.Unit.t -> Monoid.Unit.t e
                  val non : ('-> bool e) -> '-> bool e
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> 'a e) -> '-> 'a e
                  val compose : ('-> 'c e) -> ('-> 'b e) -> '-> 'c e
                end
              module Pair :
                sig
                  val fst : ('a * 'b) e -> 'a e
                  val snd : ('a * 'b) e -> 'b e
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c) e -> 'a e
                  val snd : ('a * 'b * 'c) e -> 'b e
                  val trd : ('a * 'b * 'c) e -> 'c e
                end
              module Lift :
                sig
                  val nullary : '-> 'a e
                  val unary : ('-> 'b) -> 'a e -> 'b e
                  val binary : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
                  val ternary :
                    ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    'a e -> 'b e -> 'c e -> 'd e -> 'e e
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> Monoid.Unit.t e) ->
                    f:(Monoid.Unit.t -> 'a e) -> catch:(exn -> 'a e) -> 'a e
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : 'a e t -> 'a t e
                      val all_ignore : 'a e t -> Monoid.Unit.t e
                      val sequence : Monoid.Unit.t e t -> Monoid.Unit.t e
                      val map : 'a t -> f:('-> 'b e) -> 'b t e
                      val iter :
                        'a t -> f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                      val fold :
                        'a t -> init:'-> f:('-> '-> 'b e) -> 'b e
                      val fold_left :
                        'a t -> init:'-> f:('-> '-> 'b e) -> 'b e
                      val fold_right :
                        'a t -> f:('-> '-> 'b e) -> init:'-> 'b e
                      val reduce :
                        'a t -> f:('-> '-> 'a e) -> 'Option.t e
                      val exists : 'a t -> f:('-> bool e) -> bool e
                      val for_all : 'a t -> f:('-> bool e) -> bool e
                      val count : 'a t -> f:('-> bool e) -> Monoid.Int.t e
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> 'a e) -> 'a e
                      val find : 'a t -> f:('-> bool e) -> 'Option.t e
                      val find_map :
                        'a t -> f:('-> 'Option.t e) -> 'Option.t e
                      val filter : 'a t -> f:('-> bool e) -> 'a t e
                      val filter_map :
                        'a t -> f:('-> 'Option.t e) -> 'b t e
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : 'a e T.t -> 'T.t e
                        val all_ignore : 'a e T.t -> Monoid.Unit.t e
                        val sequence : Monoid.Unit.t e T.t -> Monoid.Unit.t e
                        val map : 'T.t -> f:('-> 'b e) -> 'T.t e
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                        val fold_right :
                          'T.t -> f:('-> '-> 'b e) -> init:'-> 'b e
                        val reduce :
                          'T.t -> f:('-> '-> 'a e) -> 'Option.t e
                        val exists : 'T.t -> f:('-> bool e) -> bool e
                        val for_all : 'T.t -> f:('-> bool e) -> bool e
                        val count :
                          'T.t -> f:('-> bool e) -> Monoid.Int.t e
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a e) -> 'a e
                        val find :
                          'T.t -> f:('-> bool e) -> 'Option.t e
                        val find_map :
                          'T.t -> f:('-> 'Option.t e) -> 'Option.t e
                        val filter : 'T.t -> f:('-> bool e) -> 'T.t e
                        val filter_map :
                          'T.t -> f:('-> 'Option.t e) -> 'T.t e
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : 'a e T.t -> 'T.t e
                        val all_ignore : 'a e T.t -> Monoid.Unit.t e
                        val sequence : Monoid.Unit.t e T.t -> Monoid.Unit.t e
                        val map : 'T.t -> f:('-> 'b e) -> 'T.t e
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                        val fold_right :
                          'T.t -> f:('-> '-> 'b e) -> init:'-> 'b e
                        val reduce :
                          'T.t -> f:('-> '-> 'a e) -> 'Option.t e
                        val exists : 'T.t -> f:('-> bool e) -> bool e
                        val for_all : 'T.t -> f:('-> bool e) -> bool e
                        val count :
                          'T.t -> f:('-> bool e) -> Monoid.Int.t e
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a e) -> 'a e
                        val find :
                          'T.t -> f:('-> bool e) -> 'Option.t e
                        val find_map :
                          'T.t -> f:('-> 'Option.t e) -> 'Option.t e
                        val filter : 'T.t -> f:('-> bool e) -> 'T.t e
                        val filter_map :
                          'T.t -> f:('-> 'Option.t e) -> 'T.t e
                      end
                end
              module List :
                sig
                  val all : 'a e List.t -> 'List.t e
                  val all_ignore : 'a e List.t -> Monoid.Unit.t e
                  val sequence : Monoid.Unit.t e List.t -> Monoid.Unit.t e
                  val map : 'List.t -> f:('-> 'b e) -> 'List.t e
                  val iter :
                    'List.t -> f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                  val fold :
                    'List.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                  val fold_left :
                    'List.t -> init:'-> f:('-> '-> 'b e) -> 'b e
                  val fold_right :
                    'List.t -> f:('-> '-> 'b e) -> init:'-> 'b e
                  val reduce :
                    'List.t -> f:('-> '-> 'a e) -> 'Option.t e
                  val exists : 'List.t -> f:('-> bool e) -> bool e
                  val for_all : 'List.t -> f:('-> bool e) -> bool e
                  val count : 'List.t -> f:('-> bool e) -> Monoid.Int.t e
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'List.t -> f:('-> 'a e) -> 'a e
                  val find : 'List.t -> f:('-> bool e) -> 'Option.t e
                  val find_map :
                    'List.t -> f:('-> 'Option.t e) -> 'Option.t e
                  val filter : 'List.t -> f:('-> bool e) -> 'List.t e
                  val filter_map :
                    'List.t -> f:('-> 'Option.t e) -> 'List.t e
                end
              module Seq :
                sig
                  val all : 'a e e -> 'a e e
                  val all_ignore : 'a e e -> Monoid.Unit.t e
                  val sequence : Monoid.Unit.t e e -> Monoid.Unit.t e
                  val map : 'a e -> f:('-> 'b e) -> 'b e e
                  val iter :
                    'a e -> f:('-> Monoid.Unit.t e) -> Monoid.Unit.t e
                  val fold : 'a e -> init:'-> f:('-> '-> 'b e) -> 'b e
                  val fold_left :
                    'a e -> init:'-> f:('-> '-> 'b e) -> 'b e
                  val fold_right :
                    'a e -> f:('-> '-> 'b e) -> init:'-> 'b e
                  val reduce : 'a e -> f:('-> '-> 'a e) -> 'Option.t e
                  val exists : 'a e -> f:('-> bool e) -> bool e
                  val for_all : 'a e -> f:('-> bool e) -> bool e
                  val count : 'a e -> f:('-> bool e) -> Monoid.Int.t e
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'b e -> f:('-> 'a e) -> 'a e
                  val find : 'a e -> f:('-> bool e) -> 'Option.t e
                  val find_map :
                    'a e -> f:('-> 'Option.t e) -> 'Option.t e
                  val filter : 'a e -> f:('-> bool e) -> 'a e e
                  val filter_map : 'a e -> f:('-> 'Option.t e) -> 'b e e
                end
              val ( >=> ) : ('-> 'b e) -> ('-> 'c e) -> '-> 'c e
              val ( !! ) : '-> 'a e
              val ( !$ ) : ('-> 'b) -> 'a e -> 'b e
              val ( !$$ ) : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a e -> 'b e -> 'c e -> 'd e -> 'e e
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
              val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
              val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
              module Monad_infix :
                sig
                  val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
                  val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
                end
              val bind : 'a e -> f:('-> 'b e) -> 'b e
              val return : '-> 'a e
              val map : 'a e -> f:('-> 'b) -> 'b e
              val join : 'a e e -> 'a e
              val ignore_m : 'a e -> Monoid.Unit.t e
              val all : 'a e list -> 'a list e
              val all_ignore : Monoid.Unit.t e list -> Monoid.Unit.t e
              module Let_syntax :
                sig
                  val return : '-> 'a e
                  val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
                  val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
                  module Let_syntax :
                    sig
                      val return : '-> 'a e
                      val bind : 'a e -> f:('-> 'b e) -> 'b e
                      val map : 'a e -> f:('-> 'b) -> 'b e
                      val both : 'a e -> 'b e -> ('a * 'b) e
                      module Open_on_rhs : sig  end
                    end
                end
              module Syntax :
                sig
                  val ( >>= ) : 'a e -> ('-> 'b e) -> 'b e
                  val ( >>| ) : 'a e -> ('-> 'b) -> 'b e
                  val ( >=> ) : ('-> 'b e) -> ('-> 'c e) -> '-> 'c e
                  val ( !! ) : '-> 'a e
                  val ( !$ ) : ('-> 'b) -> 'a e -> 'b e
                  val ( !$$ ) : ('-> '-> 'c) -> 'a e -> 'b e -> 'c e
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a e -> 'b e -> 'c e -> 'd e
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a e -> 'b e -> 'c e -> 'd e -> 'e e
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a e -> 'b e -> 'c e -> 'd e -> 'e e -> 'f e
                end
              val pure : '-> 'a e
              val accept : '-> 'a e
              val reject : Monoid.Unit.t -> 'a e
              val guard : bool -> Monoid.Unit.t e
              val on : bool -> Monoid.Unit.t e -> Monoid.Unit.t e
              val unless : bool -> Monoid.Unit.t e -> Monoid.Unit.t e
              val zero : Monoid.Unit.t -> 'a e
              val plus : 'a e -> 'a e -> 'a e
              module T1 :
                functor (M : Core_kernel.Std.T1->
                  sig
                    type 'a t = 'Core_kernel.Std.Sequence.t M.t
                    type 'a m = 'M.t
                    type 'a e = 'Monads.Std.Monad.Seq.T1.t
                  end
              module Make :
                functor (M : Monad->
                  sig
                    val lift : 'M.t -> 'T1(M).t
                    val run : 'T1(M).t -> 'Monads.Std.Monad.Seq.T1.t
                    val void : 'T1(M).t -> Monoid.Unit.t T1(M).t
                    val sequence :
                      Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                    val forever : 'T1(M).t -> 'T1(M).t
                    module Fn :
                      sig
                        val id : '-> 'T1(M).t
                        val ignore : 'T1(M).t -> Monoid.Unit.t T1(M).t
                        val nothing : Monoid.Unit.t -> Monoid.Unit.t T1(M).t
                        val non : ('-> bool T1(M).t) -> '-> bool T1(M).t
                        val apply_n_times :
                          n:Monoid.Int.t ->
                          ('-> 'T1(M).t) -> '-> 'T1(M).t
                        val compose :
                          ('-> 'T1(M).t) ->
                          ('-> 'T1(M).t) -> '-> 'T1(M).t
                      end
                    module Pair :
                      sig
                        val fst : ('a * 'b) T1(M).t -> 'T1(M).t
                        val snd : ('a * 'b) T1(M).t -> 'T1(M).t
                      end
                    module Triple :
                      sig
                        val fst : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                        val snd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                        val trd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                      end
                    module Lift :
                      sig
                        val nullary : '-> 'T1(M).t
                        val unary : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                        val binary :
                          ('-> '-> 'c) ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val ternary :
                          ('-> '-> '-> 'd) ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val quaternary :
                          ('-> '-> '-> '-> 'e) ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val quinary :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                      end
                    module Exn :
                      sig
                        val expect :
                          ?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(M).t) ->
                          f:(Monoid.Unit.t -> 'T1(M).t) ->
                          catch:(exn -> 'T1(M).t) -> 'T1(M).t
                      end
                    module Collection :
                      sig
                        module type S =
                          sig
                            type 'a t
                            val all : 'T1(M).t t -> 'a t T1(M).t
                            val all_ignore :
                              'T1(M).t t -> Monoid.Unit.t T1(M).t
                            val sequence :
                              Monoid.Unit.t T1(M).t t ->
                              Monoid.Unit.t T1(M).t
                            val map :
                              'a t -> f:('-> 'T1(M).t) -> 'b t T1(M).t
                            val iter :
                              'a t ->
                              f:('-> Monoid.Unit.t T1(M).t) ->
                              Monoid.Unit.t T1(M).t
                            val fold :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T1(M).t) -> 'T1(M).t
                            val fold_left :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T1(M).t) -> 'T1(M).t
                            val fold_right :
                              'a t ->
                              f:('-> '-> 'T1(M).t) ->
                              init:'-> 'T1(M).t
                            val reduce :
                              'a t ->
                              f:('-> '-> 'T1(M).t) ->
                              'Option.t T1(M).t
                            val exists :
                              'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                            val for_all :
                              'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                            val count :
                              'a t ->
                              f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b t -> f:('-> 'T1(M).t) -> 'T1(M).t
                            val find :
                              'a t ->
                              f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                            val find_map :
                              'a t ->
                              f:('-> 'Option.t T1(M).t) ->
                              'Option.t T1(M).t
                            val filter :
                              'a t -> f:('-> bool T1(M).t) -> 'a t T1(M).t
                            val filter_map :
                              'a t ->
                              f:('-> 'Option.t T1(M).t) -> 'b t T1(M).t
                          end
                        module Eager :
                          functor (T : Collection.Eager->
                            sig
                              val all : 'T1(M).t T.t -> 'T.t T1(M).t
                              val all_ignore :
                                'T1(M).t T.t -> Monoid.Unit.t T1(M).t
                              val sequence :
                                Monoid.Unit.t T1(M).t T.t ->
                                Monoid.Unit.t T1(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T1(M).t) -> 'T.t T1(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T1(M).t) ->
                                Monoid.Unit.t T1(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(M).t) -> 'T1(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(M).t) -> 'T1(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T1(M).t) ->
                                init:'-> 'T1(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T1(M).t) ->
                                'Option.t T1(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T1(M).t) -> bool T1(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T1(M).t) -> bool T1(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T1(M).t) ->
                                Monoid.Int.t T1(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'Option.t T1(M).t) ->
                                'Option.t T1(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T1(M).t) -> 'T.t T1(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'Option.t T1(M).t) ->
                                'T.t T1(M).t
                            end
                        module Delay :
                          functor (T : Collection.Delay->
                            sig
                              val all : 'T1(M).t T.t -> 'T.t T1(M).t
                              val all_ignore :
                                'T1(M).t T.t -> Monoid.Unit.t T1(M).t
                              val sequence :
                                Monoid.Unit.t T1(M).t T.t ->
                                Monoid.Unit.t T1(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T1(M).t) -> 'T.t T1(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T1(M).t) ->
                                Monoid.Unit.t T1(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(M).t) -> 'T1(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(M).t) -> 'T1(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T1(M).t) ->
                                init:'-> 'T1(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T1(M).t) ->
                                'Option.t T1(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T1(M).t) -> bool T1(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T1(M).t) -> bool T1(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T1(M).t) ->
                                Monoid.Int.t T1(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'Option.t T1(M).t) ->
                                'Option.t T1(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T1(M).t) -> 'T.t T1(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'Option.t T1(M).t) ->
                                'T.t T1(M).t
                            end
                      end
                    module List :
                      sig
                        val all : 'T1(M).t list -> 'a list T1(M).t
                        val all_ignore :
                          'T1(M).t list -> Monoid.Unit.t T1(M).t
                        val sequence :
                          Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                        val map :
                          'a list -> f:('-> 'T1(M).t) -> 'b list T1(M).t
                        val iter :
                          'a list ->
                          f:('-> Monoid.Unit.t T1(M).t) ->
                          Monoid.Unit.t T1(M).t
                        val fold :
                          'a list ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_left :
                          'a list ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_right :
                          'a list ->
                          f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                        val reduce :
                          'a list ->
                          f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                        val exists :
                          'a list -> f:('-> bool T1(M).t) -> bool T1(M).t
                        val for_all :
                          'a list -> f:('-> bool T1(M).t) -> bool T1(M).t
                        val count :
                          'a list ->
                          f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b list -> f:('-> 'T1(M).t) -> 'T1(M).t
                        val find :
                          'a list ->
                          f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                        val find_map :
                          'a list ->
                          f:('-> 'Option.t T1(M).t) ->
                          'Option.t T1(M).t
                        val filter :
                          'a list ->
                          f:('-> bool T1(M).t) -> 'a list T1(M).t
                        val filter_map :
                          'a list ->
                          f:('-> 'Option.t T1(M).t) -> 'b list T1(M).t
                      end
                    module Seq :
                      sig
                        val all : 'T1(M).t e -> 'a e T1(M).t
                        val all_ignore :
                          'T1(M).t e -> Monoid.Unit.t T1(M).t
                        val sequence :
                          Monoid.Unit.t T1(M).t e -> Monoid.Unit.t T1(M).t
                        val map :
                          'a e -> f:('-> 'T1(M).t) -> 'b e T1(M).t
                        val iter :
                          'a e ->
                          f:('-> Monoid.Unit.t T1(M).t) ->
                          Monoid.Unit.t T1(M).t
                        val fold :
                          'a e ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_left :
                          'a e ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_right :
                          'a e ->
                          f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                        val reduce :
                          'a e ->
                          f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                        val exists :
                          'a e -> f:('-> bool T1(M).t) -> bool T1(M).t
                        val for_all :
                          'a e -> f:('-> bool T1(M).t) -> bool T1(M).t
                        val count :
                          'a e ->
                          f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b e -> f:('-> 'T1(M).t) -> 'T1(M).t
                        val find :
                          'a e ->
                          f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                        val find_map :
                          'a e ->
                          f:('-> 'Option.t T1(M).t) ->
                          'Option.t T1(M).t
                        val filter :
                          'a e -> f:('-> bool T1(M).t) -> 'a e T1(M).t
                        val filter_map :
                          'a e ->
                          f:('-> 'Option.t T1(M).t) -> 'b e T1(M).t
                      end
                    val ( >=> ) :
                      ('-> 'T1(M).t) ->
                      ('-> 'T1(M).t) -> '-> 'T1(M).t
                    val ( !! ) : '-> 'T1(M).t
                    val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(M).t ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( >>= ) :
                      'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                    val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                        val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                      end
                    val bind :
                      'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
                    val return : '-> 'T1(M).t
                    val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                    val join : 'T1(M).t T1(M).t -> 'T1(M).t
                    val ignore_m : 'T1(M).t -> Monoid.Unit.t T1(M).t
                    val all : 'T1(M).t list -> 'a list T1(M).t
                    val all_ignore :
                      Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T1(M).t
                        val ( >>= ) :
                          'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                        val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                        module Let_syntax :
                          sig
                            val return : '-> 'T1(M).t
                            val bind :
                              'T1(M).t ->
                              f:('-> 'T1(M).t) -> 'T1(M).t
                            val map :
                              'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                            val both :
                              'T1(M).t -> 'T1(M).t -> ('a * 'b) T1(M).t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Syntax :
                      sig
                        val ( >>= ) :
                          'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                        val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                        val ( >=> ) :
                          ('-> 'T1(M).t) ->
                          ('-> 'T1(M).t) -> '-> 'T1(M).t
                        val ( !! ) : '-> 'T1(M).t
                        val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                      end
                    val pure : '-> 'T1(M).t
                    val accept : '-> 'T1(M).t
                    val reject : Monoid.Unit.t -> 'T1(M).t
                    val guard : bool -> Monoid.Unit.t T1(M).t
                    val on :
                      bool -> Monoid.Unit.t T1(M).t -> Monoid.Unit.t T1(M).t
                    val unless :
                      bool -> Monoid.Unit.t T1(M).t -> Monoid.Unit.t T1(M).t
                    val zero : Monoid.Unit.t -> 'T1(M).t
                    val plus : 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                  end
              module T2 :
                functor (M : Core_kernel.Std.T2->
                  sig
                    type ('a, 'e) t = ('Core_kernel.Std.Sequence.t, 'e) M.t
                    type ('a, 'e) m = ('a, 'e) M.t
                    type ('a, 'e) e = ('a, 'e) Monads.Std.Monad.Seq.T2.t
                  end
              module Make2 :
                functor (M : Monad2->
                  sig
                    val lift : ('a, 'e) M.t -> ('a, 'e) T2(M).t
                    val run :
                      ('a, 'e) T2(M).t -> ('a, 'e) Monads.Std.Monad.Seq.T2.t
                    val void :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    module Fn :
                      sig
                        val id : '-> ('a, 'e) T2(M).t
                        val ignore :
                          ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                        val nothing :
                          Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
                        val non :
                          ('-> (bool, 'e) T2(M).t) ->
                          '-> (bool, 'e) T2(M).t
                        val apply_n_times :
                          n:Monoid.Int.t ->
                          ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                        val compose :
                          ('-> ('c, 'e) T2(M).t) ->
                          ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                      end
                    module Pair :
                      sig
                        val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                        val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
                      end
                    module Triple :
                      sig
                        val fst :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                        val snd :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val trd :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
                      end
                    module Lift :
                      sig
                        val nullary : '-> ('a, 'e) T2(M).t
                        val unary :
                          ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val binary :
                          ('-> '-> 'c) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                        val ternary :
                          ('-> '-> '-> 'd) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t ->
                          ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                        val quaternary :
                          ('-> '-> '-> '-> 'e) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                        val quinary :
                          ('-> '-> '-> '-> '-> 'f) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t ->
                          ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                      end
                    module Exn :
                      sig
                        val expect :
                          ?finally:(Monoid.Unit.t ->
                                    (Monoid.Unit.t, 's) T2(M).t) ->
                          f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
                          catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
                      end
                    module Collection :
                      sig
                        module type S =
                          sig
                            type 'a t
                            val all :
                              ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                            val all_ignore :
                              ('a, 'e) T2(M).t t ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val sequence :
                              (Monoid.Unit.t, 'e) T2(M).t t ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val map :
                              'a t ->
                              f:('-> ('b, 'e) T2(M).t) ->
                              ('b t, 'e) T2(M).t
                            val iter :
                              'a t ->
                              f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val fold :
                              'a t ->
                              init:'->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              ('b, 'e) T2(M).t
                            val fold_left :
                              'a t ->
                              init:'->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              ('b, 'e) T2(M).t
                            val fold_right :
                              'a t ->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              init:'-> ('b, 'e) T2(M).t
                            val reduce :
                              'a t ->
                              f:('-> '-> ('a, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val exists :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (bool, 'e) T2(M).t
                            val for_all :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (bool, 'e) T2(M).t
                            val count :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (Monoid.Int.t, 'e) T2(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b t ->
                              f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                            val find :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val find_map :
                              'a t ->
                              f:('-> ('Option.t, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val filter :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              ('a t, 'e) T2(M).t
                            val filter_map :
                              'a t ->
                              f:('-> ('Option.t, 'e) T2(M).t) ->
                              ('b t, 'e) T2(M).t
                          end
                        module Eager :
                          functor (T : Collection.Eager->
                            sig
                              val all :
                                ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                              val all_ignore :
                                ('a, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val sequence :
                                (Monoid.Unit.t, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val map :
                                'T.t ->
                                f:('-> ('b, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val iter :
                                'T.t ->
                                f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                init:'-> ('b, 'e) T2(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> ('a, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val exists :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val for_all :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val count :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (Monoid.Int.t, 'e) T2(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> ('a, 'e) T2(M).t) ->
                                ('a, 'e) T2(M).t
                              val find :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val find_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val filter :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                            end
                        module Delay :
                          functor (T : Collection.Delay->
                            sig
                              val all :
                                ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                              val all_ignore :
                                ('a, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val sequence :
                                (Monoid.Unit.t, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val map :
                                'T.t ->
                                f:('-> ('b, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val iter :
                                'T.t ->
                                f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                init:'-> ('b, 'e) T2(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> ('a, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val exists :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val for_all :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val count :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (Monoid.Int.t, 'e) T2(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> ('a, 'e) T2(M).t) ->
                                ('a, 'e) T2(M).t
                              val find :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val find_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val filter :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                            end
                      end
                    module List :
                      sig
                        val all :
                          ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t list ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t list ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'a list ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                        val iter :
                          'a list ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'a list ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'a list ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'a list ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'a list ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b list ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'a list ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('a list, 'e) T2(M).t
                        val filter_map :
                          'a list ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('b list, 'e) T2(M).t
                      end
                    module Seq :
                      sig
                        val all : ('a, 'e) T2(M).t e -> ('a e, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t e -> (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t e ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'a e ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b e, 'e) T2(M).t
                        val iter :
                          'a e ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'a e ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'a e ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'a e ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'a e ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'a e ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'a e ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'a e ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b e ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'a e ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'a e ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'a e ->
                          f:('-> (bool, 'e) T2(M).t) -> ('a e, 'e) T2(M).t
                        val filter_map :
                          'a e ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('b e, 'e) T2(M).t
                      end
                    val ( >=> ) :
                      ('-> ('b, 'e) T2(M).t) ->
                      ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                    val ( !! ) : '-> ('a, 'e) T2(M).t
                    val ( !$ ) :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) T2(M).t
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                        module Let_syntax :
                          sig
                            val return : '-> ('a, 'b) T2(M).t
                            val bind :
                              ('a, 'e) T2(M).t ->
                              f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                            val map :
                              ('a, 'e) T2(M).t ->
                              f:('-> 'b) -> ('b, 'e) T2(M).t
                            val both :
                              ('a, 'e) T2(M).t ->
                              ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                      end
                    val bind :
                      ('a, 'e) T2(M).t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val return : '-> ('a, 'b) T2(M).t
                    val map :
                      ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                    val join :
                      (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val ignore_m :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                    val all_ignore :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    module Syntax :
                      sig
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                        val ( >=> ) :
                          ('-> ('b, 'e) T2(M).t) ->
                          ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                        val ( !! ) : '-> ('a, 'e) T2(M).t
                        val ( !$ ) :
                          ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t ->
                          ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t ->
                          ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                      end
                    val pure : '-> ('a, 'e) T2(M).t
                    val accept : '-> ('a, 'e) T2(M).t
                    val reject : Monoid.Unit.t -> ('a, 'e) T2(M).t
                    val guard : bool -> (Monoid.Unit.t, 'e) T2(M).t
                    val on :
                      bool ->
                      (Monoid.Unit.t, 'e) T2(M).t ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val unless :
                      bool ->
                      (Monoid.Unit.t, 'e) T2(M).t ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val zero : Monoid.Unit.t -> ('a, 'e) T2(M).t
                    val plus :
                      ('a, 'e) T2(M).t ->
                      ('a, 'e) T2(M).t -> ('a, 'e) T2(M).t
                  end
            end
          module Writer :
            sig
              module type S =
                sig
                  type state
                  type 'a t
                  type 'a m
                  type 'a e
                  val lift : 'a m -> 'a t
                  val run : 'a t -> 'a e
                  val write : Monads.Std.Monad.Writer.S.state -> unit t
                  val read : 'a t -> Monads.Std.Monad.Writer.S.state t
                  val listen :
                    'a t -> ('a * Monads.Std.Monad.Writer.S.state) t
                  val exec : unit t -> Monads.Std.Monad.Writer.S.state m
                  val void : 'a t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
                  val forever : 'a t -> 'b t
                  module Fn :
                    sig
                      val id : '-> 'a t
                      val ignore : 'a t -> Monoid.Unit.t t
                      val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                      val non : ('-> bool t) -> '-> bool t
                      val apply_n_times :
                        n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                      val compose :
                        ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                    end
                  module Pair :
                    sig
                      val fst : ('a * 'b) t -> 'a t
                      val snd : ('a * 'b) t -> 'b t
                    end
                  module Triple :
                    sig
                      val fst : ('a * 'b * 'c) t -> 'a t
                      val snd : ('a * 'b * 'c) t -> 'b t
                      val trd : ('a * 'b * 'c) t -> 'c t
                    end
                  module Lift :
                    sig
                      val nullary : '-> 'a t
                      val unary : ('-> 'b) -> 'a t -> 'b t
                      val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ternary :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val quaternary :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val quinary :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                  module Exn :
                    sig
                      val expect :
                        ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                        f:(Monoid.Unit.t -> 'a t) ->
                        catch:(exn -> 'a t) -> 'a t
                    end
                  module Collection :
                    sig
                      module type S =
                        sig
                          type 'a t
                          val all : 'a t t -> 'a t t
                          val all_ignore : 'a t t -> Monoid.Unit.t t
                          val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                          val map : 'a t -> f:('-> 'b t) -> 'b t t
                          val iter :
                            'a t ->
                            f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                          val fold :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_left :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_right :
                            'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                          val reduce :
                            'a t -> f:('-> '-> 'a t) -> 'Option.t t
                          val exists : 'a t -> f:('-> bool t) -> bool t
                          val for_all : 'a t -> f:('-> bool t) -> bool t
                          val count :
                            'a t -> f:('-> bool t) -> Monoid.Int.t t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b t -> f:('-> 'a t) -> 'a t
                          val find :
                            'a t -> f:('-> bool t) -> 'Option.t t
                          val find_map :
                            'a t -> f:('-> 'Option.t t) -> 'Option.t t
                          val filter : 'a t -> f:('-> bool t) -> 'a t t
                          val filter_map :
                            'a t -> f:('-> 'Option.t t) -> 'b t t
                        end
                      module Eager :
                        functor (T : Collection.Eager->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'Option.t t
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t t) -> 'Option.t t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'Option.t t) -> 'T.t t
                          end
                      module Delay :
                        functor (T : Collection.Delay->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'Option.t t
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t t) -> 'Option.t t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'Option.t t) -> 'T.t t
                          end
                    end
                  module List :
                    sig
                      val all : 'a t List.t -> 'List.t t
                      val all_ignore : 'a t List.t -> Monoid.Unit.t t
                      val sequence :
                        Monoid.Unit.t t List.t -> Monoid.Unit.t t
                      val map : 'List.t -> f:('-> 'b t) -> 'List.t t
                      val iter :
                        'List.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'List.t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'List.t -> f:('-> bool t) -> bool t
                      val for_all : 'List.t -> f:('-> bool t) -> bool t
                      val count :
                        'List.t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'List.t -> f:('-> 'a t) -> 'a t
                      val find :
                        'List.t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'List.t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter :
                        'List.t -> f:('-> bool t) -> 'List.t t
                      val filter_map :
                        'List.t -> f:('-> 'Option.t t) -> 'List.t t
                    end
                  module Seq :
                    sig
                      val all : 'a t Seq.t -> 'Seq.t t
                      val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
                      val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
                      val iter :
                        'Seq.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'Seq.t -> f:('-> bool t) -> bool t
                      val for_all : 'Seq.t -> f:('-> bool t) -> bool t
                      val count :
                        'Seq.t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'Seq.t -> f:('-> 'a t) -> 'a t
                      val find :
                        'Seq.t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
                      val filter_map :
                        'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
                    end
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Monad_infix :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                    end
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val return : '-> 'a t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val join : 'a t t -> 'a t
                  val ignore_m : 'a t -> Monoid.Unit.t t
                  val all : 'a t list -> 'a list t
                  val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      module Let_syntax :
                        sig
                          val return : '-> 'a t
                          val bind : 'a t -> f:('-> 'b t) -> 'b t
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val both : 'a t -> 'b t -> ('a * 'b) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Syntax :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      val ( >=> ) :
                        ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                      val ( !! ) : '-> 'a t
                      val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                      val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                end
              type ('a, 'b) writer
              module T1 :
                functor (T : Monoid.S) (M : Monad->
                  sig
                    type state = T.t
                    type 'a m = 'M.t
                    type 'a t =
                        ('a, Monads.Std.Monad.Writer.T1.state)
                        Monads.Std.Monad.Writer.writer
                        Monads.Std.Monad.Writer.T1.m
                    type 'a e =
                        ('a * Monads.Std.Monad.Writer.T1.state)
                        Monads.Std.Monad.Writer.T1.m
                  end
              module Make :
                functor (T : Monoid.S) (M : Monad->
                  sig
                    val lift : 'M.t -> 'T1(T)(M).t
                    val run : 'T1(T)(M).t -> 'T1(T)(M).e
                    val write : T.t -> Monoid.Unit.t T1(T)(M).t
                    val read : 'T1(T)(M).t -> T.t T1(T)(M).t
                    val listen : 'T1(T)(M).t -> ('a * T.t) T1(T)(M).t
                    val exec : Monoid.Unit.t T1(T)(M).t -> T.t M.t
                    val void : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                    val sequence :
                      Monoid.Unit.t T1(T)(M).t List.t ->
                      Monoid.Unit.t T1(T)(M).t
                    val forever : 'T1(T)(M).t -> 'T1(T)(M).t
                    module Fn :
                      sig
                        val id : '-> 'T1(T)(M).t
                        val ignore :
                          'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                        val nothing :
                          Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t
                        val non :
                          ('-> bool T1(T)(M).t) -> '-> bool T1(T)(M).t
                        val apply_n_times :
                          n:Monoid.Int.t ->
                          ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                        val compose :
                          ('-> 'T1(T)(M).t) ->
                          ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                      end
                    module Pair :
                      sig
                        val fst : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                        val snd : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                      end
                    module Triple :
                      sig
                        val fst : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                        val snd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                        val trd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                      end
                    module Lift :
                      sig
                        val nullary : '-> 'T1(T)(M).t
                        val unary :
                          ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val binary :
                          ('-> '-> 'c) ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ternary :
                          ('-> '-> '-> 'd) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val quaternary :
                          ('-> '-> '-> '-> 'e) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val quinary :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                      end
                    module Exn :
                      sig
                        val expect :
                          ?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t) ->
                          f:(Monoid.Unit.t -> 'T1(T)(M).t) ->
                          catch:(exn -> 'T1(T)(M).t) -> 'T1(T)(M).t
                      end
                    module Collection :
                      sig
                        module type S =
                          sig
                            type 'a t
                            val all : 'T1(T)(M).t t -> 'a t T1(T)(M).t
                            val all_ignore :
                              'T1(T)(M).t t -> Monoid.Unit.t T1(T)(M).t
                            val sequence :
                              Monoid.Unit.t T1(T)(M).t t ->
                              Monoid.Unit.t T1(T)(M).t
                            val map :
                              'a t ->
                              f:('-> 'T1(T)(M).t) -> 'b t T1(T)(M).t
                            val iter :
                              'a t ->
                              f:('-> Monoid.Unit.t T1(T)(M).t) ->
                              Monoid.Unit.t T1(T)(M).t
                            val fold :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val fold_left :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val fold_right :
                              'a t ->
                              f:('-> '-> 'T1(T)(M).t) ->
                              init:'-> 'T1(T)(M).t
                            val reduce :
                              'a t ->
                              f:('-> '-> 'T1(T)(M).t) ->
                              'Option.t T1(T)(M).t
                            val exists :
                              'a t ->
                              f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                            val for_all :
                              'a t ->
                              f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                            val count :
                              'a t ->
                              f:('-> bool T1(T)(M).t) ->
                              Monoid.Int.t T1(T)(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b t ->
                              f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val find :
                              'a t ->
                              f:('-> bool T1(T)(M).t) ->
                              'Option.t T1(T)(M).t
                            val find_map :
                              'a t ->
                              f:('-> 'Option.t T1(T)(M).t) ->
                              'Option.t T1(T)(M).t
                            val filter :
                              'a t ->
                              f:('-> bool T1(T)(M).t) -> 'a t T1(T)(M).t
                            val filter_map :
                              'a t ->
                              f:('-> 'Option.t T1(T)(M).t) ->
                              'b t T1(T)(M).t
                          end
                        module Eager :
                          functor (T : Collection.Eager->
                            sig
                              val all :
                                'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                              val all_ignore :
                                'T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
                              val sequence :
                                Monoid.Unit.t T1(T)(M).t T.t ->
                                Monoid.Unit.t T1(T)(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T1(T)(M).t) ->
                                Monoid.Unit.t T1(T)(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'T1(T)(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'T1(T)(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T1(T)(M).t) ->
                                init:'-> 'T1(T)(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                Monoid.Int.t T1(T)(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'Option.t T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                'T.t T1(T)(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'Option.t T1(T)(M).t) ->
                                'T.t T1(T)(M).t
                            end
                        module Delay :
                          functor (T : Collection.Delay->
                            sig
                              val all :
                                'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                              val all_ignore :
                                'T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
                              val sequence :
                                Monoid.Unit.t T1(T)(M).t T.t ->
                                Monoid.Unit.t T1(T)(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T1(T)(M).t) ->
                                Monoid.Unit.t T1(T)(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'T1(T)(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'T1(T)(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T1(T)(M).t) ->
                                init:'-> 'T1(T)(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                Monoid.Int.t T1(T)(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'Option.t T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                'T.t T1(T)(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'Option.t T1(T)(M).t) ->
                                'T.t T1(T)(M).t
                            end
                      end
                    module List :
                      sig
                        val all :
                          'T1(T)(M).t List.t -> 'List.t T1(T)(M).t
                        val all_ignore :
                          'T1(T)(M).t List.t -> Monoid.Unit.t T1(T)(M).t
                        val sequence :
                          Monoid.Unit.t T1(T)(M).t List.t ->
                          Monoid.Unit.t T1(T)(M).t
                        val map :
                          'List.t ->
                          f:('-> 'T1(T)(M).t) -> 'List.t T1(T)(M).t
                        val iter :
                          'List.t ->
                          f:('-> Monoid.Unit.t T1(T)(M).t) ->
                          Monoid.Unit.t T1(T)(M).t
                        val fold :
                          'List.t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_left :
                          'List.t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_right :
                          'List.t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          init:'-> 'T1(T)(M).t
                        val reduce :
                          'List.t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val exists :
                          'List.t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val for_all :
                          'List.t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val count :
                          'List.t ->
                          f:('-> bool T1(T)(M).t) ->
                          Monoid.Int.t T1(T)(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'List.t ->
                          f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val find :
                          'List.t ->
                          f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                        val find_map :
                          'List.t ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val filter :
                          'List.t ->
                          f:('-> bool T1(T)(M).t) -> 'List.t T1(T)(M).t
                        val filter_map :
                          'List.t ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'List.t T1(T)(M).t
                      end
                    module Seq :
                      sig
                        val all : 'T1(T)(M).t Seq.t -> 'Seq.t T1(T)(M).t
                        val all_ignore :
                          'T1(T)(M).t Seq.t -> Monoid.Unit.t T1(T)(M).t
                        val sequence :
                          Monoid.Unit.t T1(T)(M).t Seq.t ->
                          Monoid.Unit.t T1(T)(M).t
                        val map :
                          'Seq.t ->
                          f:('-> 'T1(T)(M).t) -> 'Seq.t T1(T)(M).t
                        val iter :
                          'Seq.t ->
                          f:('-> Monoid.Unit.t T1(T)(M).t) ->
                          Monoid.Unit.t T1(T)(M).t
                        val fold :
                          'Seq.t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_left :
                          'Seq.t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_right :
                          'Seq.t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          init:'-> 'T1(T)(M).t
                        val reduce :
                          'Seq.t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val exists :
                          'Seq.t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val for_all :
                          'Seq.t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val count :
                          'Seq.t ->
                          f:('-> bool T1(T)(M).t) ->
                          Monoid.Int.t T1(T)(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'Seq.t ->
                          f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val find :
                          'Seq.t ->
                          f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                        val find_map :
                          'Seq.t ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val filter :
                          'Seq.t ->
                          f:('-> bool T1(T)(M).t) -> 'Seq.t T1(T)(M).t
                        val filter_map :
                          'Seq.t ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'Seq.t T1(T)(M).t
                      end
                    val ( >=> ) :
                      ('-> 'T1(T)(M).t) ->
                      ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                    val ( !! ) : '-> 'T1(T)(M).t
                    val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( >>= ) :
                      'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val ( >>| ) :
                      'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          'T1(T)(M).t ->
                          ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val ( >>| ) :
                          'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                      end
                    val bind :
                      'T1(T)(M).t ->
                      f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val return : '-> 'T1(T)(M).t
                    val map : 'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                    val join : 'T1(T)(M).t T1(T)(M).t -> 'T1(T)(M).t
                    val ignore_m : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                    val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                    val all_ignore :
                      Monoid.Unit.t T1(T)(M).t list ->
                      Monoid.Unit.t T1(T)(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T1(T)(M).t
                        val ( >>= ) :
                          'T1(T)(M).t ->
                          ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val ( >>| ) :
                          'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                        module Let_syntax :
                          sig
                            val return : '-> 'T1(T)(M).t
                            val bind :
                              'T1(T)(M).t ->
                              f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val map :
                              'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                            val both :
                              'T1(T)(M).t ->
                              'T1(T)(M).t -> ('a * 'b) T1(T)(M).t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Syntax :
                      sig
                        val ( >>= ) :
                          'T1(T)(M).t ->
                          ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val ( >>| ) :
                          'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                        val ( >=> ) :
                          ('-> 'T1(T)(M).t) ->
                          ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                        val ( !! ) : '-> 'T1(T)(M).t
                        val ( !$ ) :
                          ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                      end
                  end
            end
          module Reader :
            sig
              module type S =
                sig
                  type 'a t
                  type 'a m
                  type 'a e
                  val lift : 'a m -> 'a t
                  val run : 'a t -> 'a e
                  type env
                  val read : unit -> Monads.Std.Monad.Reader.S.env t
                  val void : 'a t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
                  val forever : 'a t -> 'b t
                  module Fn :
                    sig
                      val id : '-> 'a t
                      val ignore : 'a t -> Monoid.Unit.t t
                      val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                      val non : ('-> bool t) -> '-> bool t
                      val apply_n_times :
                        n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                      val compose :
                        ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                    end
                  module Pair :
                    sig
                      val fst : ('a * 'b) t -> 'a t
                      val snd : ('a * 'b) t -> 'b t
                    end
                  module Triple :
                    sig
                      val fst : ('a * 'b * 'c) t -> 'a t
                      val snd : ('a * 'b * 'c) t -> 'b t
                      val trd : ('a * 'b * 'c) t -> 'c t
                    end
                  module Lift :
                    sig
                      val nullary : '-> 'a t
                      val unary : ('-> 'b) -> 'a t -> 'b t
                      val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ternary :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val quaternary :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val quinary :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                  module Exn :
                    sig
                      val expect :
                        ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                        f:(Monoid.Unit.t -> 'a t) ->
                        catch:(exn -> 'a t) -> 'a t
                    end
                  module Collection :
                    sig
                      module type S =
                        sig
                          type 'a t
                          val all : 'a t t -> 'a t t
                          val all_ignore : 'a t t -> Monoid.Unit.t t
                          val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                          val map : 'a t -> f:('-> 'b t) -> 'b t t
                          val iter :
                            'a t ->
                            f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                          val fold :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_left :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_right :
                            'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                          val reduce :
                            'a t -> f:('-> '-> 'a t) -> 'Option.t t
                          val exists : 'a t -> f:('-> bool t) -> bool t
                          val for_all : 'a t -> f:('-> bool t) -> bool t
                          val count :
                            'a t -> f:('-> bool t) -> Monoid.Int.t t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b t -> f:('-> 'a t) -> 'a t
                          val find :
                            'a t -> f:('-> bool t) -> 'Option.t t
                          val find_map :
                            'a t -> f:('-> 'Option.t t) -> 'Option.t t
                          val filter : 'a t -> f:('-> bool t) -> 'a t t
                          val filter_map :
                            'a t -> f:('-> 'Option.t t) -> 'b t t
                        end
                      module Eager :
                        functor (T : Collection.Eager->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'Option.t t
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t t) -> 'Option.t t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'Option.t t) -> 'T.t t
                          end
                      module Delay :
                        functor (T : Collection.Delay->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'Option.t t
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t t) -> 'Option.t t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'Option.t t) -> 'T.t t
                          end
                    end
                  module List :
                    sig
                      val all : 'a t List.t -> 'List.t t
                      val all_ignore : 'a t List.t -> Monoid.Unit.t t
                      val sequence :
                        Monoid.Unit.t t List.t -> Monoid.Unit.t t
                      val map : 'List.t -> f:('-> 'b t) -> 'List.t t
                      val iter :
                        'List.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'List.t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'List.t -> f:('-> bool t) -> bool t
                      val for_all : 'List.t -> f:('-> bool t) -> bool t
                      val count :
                        'List.t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'List.t -> f:('-> 'a t) -> 'a t
                      val find :
                        'List.t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'List.t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter :
                        'List.t -> f:('-> bool t) -> 'List.t t
                      val filter_map :
                        'List.t -> f:('-> 'Option.t t) -> 'List.t t
                    end
                  module Seq :
                    sig
                      val all : 'a t Seq.t -> 'Seq.t t
                      val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
                      val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
                      val iter :
                        'Seq.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'Seq.t -> f:('-> bool t) -> bool t
                      val for_all : 'Seq.t -> f:('-> bool t) -> bool t
                      val count :
                        'Seq.t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'Seq.t -> f:('-> 'a t) -> 'a t
                      val find :
                        'Seq.t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
                      val filter_map :
                        'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
                    end
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Monad_infix :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                    end
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val return : '-> 'a t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val join : 'a t t -> 'a t
                  val ignore_m : 'a t -> Monoid.Unit.t t
                  val all : 'a t list -> 'a list t
                  val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      module Let_syntax :
                        sig
                          val return : '-> 'a t
                          val bind : 'a t -> f:('-> 'b t) -> 'b t
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val both : 'a t -> 'b t -> ('a * 'b) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Syntax :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      val ( >=> ) :
                        ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                      val ( !! ) : '-> 'a t
                      val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                      val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                end
              module type S2 =
                sig
                  type ('a, 'e) t
                  type 'a m
                  type ('a, 'e) e
                  val lift : 'a m -> ('a, 'e) t
                  val run : ('a, 'e) t -> ('a, 'e) e
                  val read : unit -> ('e, 'e) t
                  val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val forever : ('a, 'e) t -> ('b, 'e) t
                  module Fn :
                    sig
                      val id : '-> ('a, 'e) t
                      val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                      val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                      val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                      val apply_n_times :
                        n:Monoid.Int.t ->
                        ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                      val compose :
                        ('-> ('c, 'e) t) ->
                        ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                    end
                  module Pair :
                    sig
                      val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                      val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                    end
                  module Triple :
                    sig
                      val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                      val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                      val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                    end
                  module Lift :
                    sig
                      val nullary : '-> ('a, 'e) t
                      val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                      val binary :
                        ('-> '-> 'c) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                      val ternary :
                        ('-> '-> '-> 'd) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                      val quaternary :
                        ('-> '-> '-> '-> 'e) ->
                        ('a, 's) t ->
                        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                      val quinary :
                        ('-> '-> '-> '-> '-> 'f) ->
                        ('a, 's) t ->
                        ('b, 's) t ->
                        ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                    end
                  module Exn :
                    sig
                      val expect :
                        ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                        f:(Monoid.Unit.t -> ('a, 's) t) ->
                        catch:(exn -> ('a, 's) t) -> ('a, 's) t
                    end
                  module Collection :
                    sig
                      module type S =
                        sig
                          type 'a t
                          val all : ('a, 'e) t t -> ('a t, 'e) t
                          val all_ignore :
                            ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
                          val sequence :
                            (Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
                          val map :
                            'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                          val iter :
                            'a t ->
                            f:('-> (Monoid.Unit.t, 'e) t) ->
                            (Monoid.Unit.t, 'e) t
                          val fold :
                            'a t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_left :
                            'a t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_right :
                            'a t ->
                            f:('-> '-> ('b, 'e) t) ->
                            init:'-> ('b, 'e) t
                          val reduce :
                            'a t ->
                            f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                          val exists :
                            'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val for_all :
                            'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val count :
                            'a t ->
                            f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                          val find :
                            'a t ->
                            f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                          val find_map :
                            'a t ->
                            f:('-> ('Option.t, 'e) t) ->
                            ('Option.t, 'e) t
                          val filter :
                            'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                          val filter_map :
                            'a t ->
                            f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                        end
                      module Eager :
                        functor (T : Collection.Eager->
                          sig
                            val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                            val all_ignore :
                              ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                            val sequence :
                              (Monoid.Unit.t, 'e) t T.t ->
                              (Monoid.Unit.t, 'e) t
                            val map :
                              'T.t ->
                              f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                            val iter :
                              'T.t ->
                              f:('-> (Monoid.Unit.t, 'e) t) ->
                              (Monoid.Unit.t, 'e) t
                            val fold :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_left :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> ('b, 'e) t) ->
                              init:'-> ('b, 'e) t
                            val reduce :
                              'T.t ->
                              f:('-> '-> ('a, 'e) t) ->
                              ('Option.t, 'e) t
                            val exists :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val for_all :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val count :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                            val find :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                            val find_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) ->
                              ('Option.t, 'e) t
                            val filter :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                            val filter_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                          end
                      module Delay :
                        functor (T : Collection.Delay->
                          sig
                            val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                            val all_ignore :
                              ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                            val sequence :
                              (Monoid.Unit.t, 'e) t T.t ->
                              (Monoid.Unit.t, 'e) t
                            val map :
                              'T.t ->
                              f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                            val iter :
                              'T.t ->
                              f:('-> (Monoid.Unit.t, 'e) t) ->
                              (Monoid.Unit.t, 'e) t
                            val fold :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_left :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> ('b, 'e) t) ->
                              init:'-> ('b, 'e) t
                            val reduce :
                              'T.t ->
                              f:('-> '-> ('a, 'e) t) ->
                              ('Option.t, 'e) t
                            val exists :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val for_all :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val count :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                            val find :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                            val find_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) ->
                              ('Option.t, 'e) t
                            val filter :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                            val filter_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                          end
                    end
                  module List :
                    sig
                      val all : ('a, 'e) t List.t -> ('List.t, 'e) t
                      val all_ignore :
                        ('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                      val map :
                        'List.t ->
                        f:('-> ('b, 'e) t) -> ('List.t, 'e) t
                      val iter :
                        'List.t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'List.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'List.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'List.t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'List.t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'List.t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'List.t ->
                        f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'List.t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'List.t ->
                        f:('-> (bool, 'e) t) -> ('List.t, 'e) t
                      val filter_map :
                        'List.t ->
                        f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
                    end
                  module Seq :
                    sig
                      val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
                      val all_ignore :
                        ('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                      val map :
                        'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
                      val iter :
                        'Seq.t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'Seq.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'Seq.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'Seq.t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'Seq.t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'Seq.t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'Seq.t ->
                        f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'Seq.t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'Seq.t ->
                        f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
                      val filter_map :
                        'Seq.t ->
                        f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
                    end
                  val ( >=> ) :
                    ('-> ('b, 'e) t) ->
                    ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                  val ( !! ) : '-> ('a, 'e) t
                  val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      module Let_syntax :
                        sig
                          val return : '-> ('a, 'b) t
                          val bind :
                            ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                          val both :
                            ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Monad_infix :
                    sig
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                    end
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val return : '-> ('a, 'b) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                  val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val all : ('a, 'e) t list -> ('a list, 'e) t
                  val all_ignore :
                    (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                  module Syntax :
                    sig
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      val ( >=> ) :
                        ('-> ('b, 'e) t) ->
                        ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                      val ( !! ) : '-> ('a, 'e) t
                      val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                      val ( !$$ ) :
                        ('-> '-> 'c) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        ('a, 's) t ->
                        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        ('a, 's) t ->
                        ('b, 's) t ->
                        ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                    end
                end
              type ('a, 'b) reader
              type ('a, 'e) t = ('a, 'e) reader
              type 'a m = 'a
              type ('a, 'e) e = '-> 'a
              val lift : '-> ('a, 'e) t
              val run : ('a, 'e) t -> ('a, 'e) e
              val read : Monoid.Unit.t -> ('e, 'e) t
              val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val sequence :
                (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
              val forever : ('a, 'e) t -> ('b, 'e) t
              module Fn :
                sig
                  val id : '-> ('a, 'e) t
                  val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                  val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                  val compose :
                    ('-> ('c, 'e) t) ->
                    ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                end
              module Pair :
                sig
                  val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                  val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                end
              module Lift :
                sig
                  val nullary : '-> ('a, 'e) t
                  val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val binary :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ternary :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                    f:(Monoid.Unit.t -> ('a, 's) t) ->
                    catch:(exn -> ('a, 's) t) -> ('a, 's) t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : ('a, 'e) reader t -> ('a t, 'e) reader
                      val all_ignore :
                        ('a, 'e) reader t -> (Monoid.Unit.t, 'e) reader
                      val sequence :
                        (Monoid.Unit.t, 'e) reader t ->
                        (Monoid.Unit.t, 'e) reader
                      val map :
                        'a t ->
                        f:('-> ('b, 'e) reader) -> ('b t, 'e) reader
                      val iter :
                        'a t ->
                        f:('-> (Monoid.Unit.t, 'e) reader) ->
                        (Monoid.Unit.t, 'e) reader
                      val fold :
                        'a t ->
                        init:'->
                        f:('-> '-> ('b, 'e) reader) -> ('b, 'e) reader
                      val fold_left :
                        'a t ->
                        init:'->
                        f:('-> '-> ('b, 'e) reader) -> ('b, 'e) reader
                      val fold_right :
                        'a t ->
                        f:('-> '-> ('b, 'e) reader) ->
                        init:'-> ('b, 'e) reader
                      val reduce :
                        'a t ->
                        f:('-> '-> ('a, 'e) reader) ->
                        ('Option.t, 'e) reader
                      val exists :
                        'a t ->
                        f:('-> (bool, 'e) reader) -> (bool, 'e) reader
                      val for_all :
                        'a t ->
                        f:('-> (bool, 'e) reader) -> (bool, 'e) reader
                      val count :
                        'a t ->
                        f:('-> (bool, 'e) reader) ->
                        (Monoid.Int.t, 'e) reader
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> ('a, 'e) reader) -> ('a, 'e) reader
                      val find :
                        'a t ->
                        f:('-> (bool, 'e) reader) ->
                        ('Option.t, 'e) reader
                      val find_map :
                        'a t ->
                        f:('-> ('Option.t, 'e) reader) ->
                        ('Option.t, 'e) reader
                      val filter :
                        'a t ->
                        f:('-> (bool, 'e) reader) -> ('a t, 'e) reader
                      val filter_map :
                        'a t ->
                        f:('-> ('Option.t, 'e) reader) ->
                        ('b t, 'e) reader
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) ->
                          ('Option.t, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) ->
                          ('Option.t, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                      end
                end
              module List :
                sig
                  val all : ('a, 'e) t List.t -> ('List.t, 'e) t
                  val all_ignore : ('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val map :
                    'List.t -> f:('-> ('b, 'e) t) -> ('List.t, 'e) t
                  val iter :
                    'List.t ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'List.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'List.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'List.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'List.t ->
                    f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists :
                    'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'List.t ->
                    f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'List.t ->
                    f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'List.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter :
                    'List.t -> f:('-> (bool, 'e) t) -> ('List.t, 'e) t
                  val filter_map :
                    'List.t ->
                    f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
                end
              module Seq :
                sig
                  val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
                  val all_ignore : ('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                  val map :
                    'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
                  val iter :
                    'Seq.t ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'Seq.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'Seq.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'Seq.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'Seq.t ->
                    f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists :
                    'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'Seq.t ->
                    f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'Seq.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'Seq.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter :
                    'Seq.t -> f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
                  val filter_map :
                    'Seq.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
                end
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val bind :
                        ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                      val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Monad_infix :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                end
              val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
              val return : '-> ('a, 'b) t
              val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
              val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
              val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val all : ('a, 'e) t list -> ('a list, 'e) t
              val all_ignore :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              module Syntax :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  val ( >=> ) :
                    ('-> ('b, 'e) t) ->
                    ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                  val ( !! ) : '-> ('a, 'e) t
                  val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
              module T1 :
                functor (T : Core_kernel.Std.T) (M : Monad->
                  sig
                    type env = T.t
                    type 'a m = 'M.t
                    type 'a t =
                        ('Monads.Std.Monad.Reader.T1.m,
                         Monads.Std.Monad.Reader.T1.env)
                        Monads.Std.Monad.Reader.reader
                    type 'a e =
                        Monads.Std.Monad.Reader.T1.env ->
                        'Monads.Std.Monad.Reader.T1.m
                  end
              module T2 :
                functor (M : Monad->
                  sig
                    type 'a m = 'M.t
                    type ('a, 'e) t =
                        ('Monads.Std.Monad.Reader.T2.m, 'e)
                        Monads.Std.Monad.Reader.reader
                    type ('a, 'e) e = '-> 'Monads.Std.Monad.Reader.T2.m
                  end
              module Make :
                functor (T : Core_kernel.Std.T) (M : Monad->
                  sig
                    val lift : 'M.t -> 'T1(T)(M).t
                    val run : 'T1(T)(M).t -> 'T1(T)(M).e
                    val read : Monoid.Unit.t -> T.t T1(T)(M).t
                    val void : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                    val sequence :
                      Monoid.Unit.t T1(T)(M).t list ->
                      Monoid.Unit.t T1(T)(M).t
                    val forever : 'T1(T)(M).t -> 'T1(T)(M).t
                    module Fn :
                      sig
                        val id : '-> 'T1(T)(M).t
                        val ignore :
                          'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                        val nothing :
                          Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t
                        val non :
                          ('-> bool T1(T)(M).t) -> '-> bool T1(T)(M).t
                        val apply_n_times :
                          n:Monoid.Int.t ->
                          ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                        val compose :
                          ('-> 'T1(T)(M).t) ->
                          ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                      end
                    module Pair :
                      sig
                        val fst : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                        val snd : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                      end
                    module Triple :
                      sig
                        val fst : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                        val snd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                        val trd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                      end
                    module Lift :
                      sig
                        val nullary : '-> 'T1(T)(M).t
                        val unary :
                          ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val binary :
                          ('-> '-> 'c) ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ternary :
                          ('-> '-> '-> 'd) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val quaternary :
                          ('-> '-> '-> '-> 'e) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val quinary :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                      end
                    module Exn :
                      sig
                        val expect :
                          ?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t) ->
                          f:(Monoid.Unit.t -> 'T1(T)(M).t) ->
                          catch:(exn -> 'T1(T)(M).t) -> 'T1(T)(M).t
                      end
                    module Collection :
                      sig
                        module type S =
                          sig
                            type 'a t
                            val all : 'T1(T)(M).t t -> 'a t T1(T)(M).t
                            val all_ignore :
                              'T1(T)(M).t t -> Monoid.Unit.t T1(T)(M).t
                            val sequence :
                              Monoid.Unit.t T1(T)(M).t t ->
                              Monoid.Unit.t T1(T)(M).t
                            val map :
                              'a t ->
                              f:('-> 'T1(T)(M).t) -> 'b t T1(T)(M).t
                            val iter :
                              'a t ->
                              f:('-> Monoid.Unit.t T1(T)(M).t) ->
                              Monoid.Unit.t T1(T)(M).t
                            val fold :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val fold_left :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val fold_right :
                              'a t ->
                              f:('-> '-> 'T1(T)(M).t) ->
                              init:'-> 'T1(T)(M).t
                            val reduce :
                              'a t ->
                              f:('-> '-> 'T1(T)(M).t) ->
                              'Option.t T1(T)(M).t
                            val exists :
                              'a t ->
                              f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                            val for_all :
                              'a t ->
                              f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                            val count :
                              'a t ->
                              f:('-> bool T1(T)(M).t) ->
                              Monoid.Int.t T1(T)(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b t ->
                              f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val find :
                              'a t ->
                              f:('-> bool T1(T)(M).t) ->
                              'Option.t T1(T)(M).t
                            val find_map :
                              'a t ->
                              f:('-> 'Option.t T1(T)(M).t) ->
                              'Option.t T1(T)(M).t
                            val filter :
                              'a t ->
                              f:('-> bool T1(T)(M).t) -> 'a t T1(T)(M).t
                            val filter_map :
                              'a t ->
                              f:('-> 'Option.t T1(T)(M).t) ->
                              'b t T1(T)(M).t
                          end
                        module Eager :
                          functor (T : Collection.Eager->
                            sig
                              val all :
                                'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                              val all_ignore :
                                'T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
                              val sequence :
                                Monoid.Unit.t T1(T)(M).t T.t ->
                                Monoid.Unit.t T1(T)(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T1(T)(M).t) ->
                                Monoid.Unit.t T1(T)(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'T1(T)(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'T1(T)(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T1(T)(M).t) ->
                                init:'-> 'T1(T)(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                Monoid.Int.t T1(T)(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'Option.t T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                'T.t T1(T)(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'Option.t T1(T)(M).t) ->
                                'T.t T1(T)(M).t
                            end
                        module Delay :
                          functor (T : Collection.Delay->
                            sig
                              val all :
                                'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                              val all_ignore :
                                'T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
                              val sequence :
                                Monoid.Unit.t T1(T)(M).t T.t ->
                                Monoid.Unit.t T1(T)(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T1(T)(M).t) ->
                                Monoid.Unit.t T1(T)(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'T1(T)(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'T1(T)(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T1(T)(M).t) ->
                                init:'-> 'T1(T)(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                Monoid.Int.t T1(T)(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'Option.t T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                'T.t T1(T)(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'Option.t T1(T)(M).t) ->
                                'T.t T1(T)(M).t
                            end
                      end
                    module List :
                      sig
                        val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                        val all_ignore :
                          'T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
                        val sequence :
                          Monoid.Unit.t T1(T)(M).t list ->
                          Monoid.Unit.t T1(T)(M).t
                        val map :
                          'a list ->
                          f:('-> 'T1(T)(M).t) -> 'b list T1(T)(M).t
                        val iter :
                          'a list ->
                          f:('-> Monoid.Unit.t T1(T)(M).t) ->
                          Monoid.Unit.t T1(T)(M).t
                        val fold :
                          'a list ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_left :
                          'a list ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_right :
                          'a list ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          init:'-> 'T1(T)(M).t
                        val reduce :
                          'a list ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val exists :
                          'a list ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val for_all :
                          'a list ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val count :
                          'a list ->
                          f:('-> bool T1(T)(M).t) ->
                          Monoid.Int.t T1(T)(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b list -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val find :
                          'a list ->
                          f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                        val find_map :
                          'a list ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val filter :
                          'a list ->
                          f:('-> bool T1(T)(M).t) -> 'a list T1(T)(M).t
                        val filter_map :
                          'a list ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'b list T1(T)(M).t
                      end
                    module Seq :
                      sig
                        val all :
                          'T1(T)(M).t Core_kernel.Std.Sequence.t ->
                          'Core_kernel.Std.Sequence.t T1(T)(M).t
                        val all_ignore :
                          'T1(T)(M).t Core_kernel.Std.Sequence.t ->
                          Monoid.Unit.t T1(T)(M).t
                        val sequence :
                          Monoid.Unit.t T1(T)(M).t Core_kernel.Std.Sequence.t ->
                          Monoid.Unit.t T1(T)(M).t
                        val map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'T1(T)(M).t) ->
                          'Core_kernel.Std.Sequence.t T1(T)(M).t
                        val iter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> Monoid.Unit.t T1(T)(M).t) ->
                          Monoid.Unit.t T1(T)(M).t
                        val fold :
                          'Core_kernel.Std.Sequence.t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_left :
                          'Core_kernel.Std.Sequence.t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_right :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          init:'-> 'T1(T)(M).t
                        val reduce :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val exists :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val for_all :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val count :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(T)(M).t) ->
                          Monoid.Int.t T1(T)(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val find :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                        val find_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val filter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(T)(M).t) ->
                          'Core_kernel.Std.Sequence.t T1(T)(M).t
                        val filter_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'Core_kernel.Std.Sequence.t T1(T)(M).t
                      end
                    val ( >=> ) :
                      ('-> 'T1(T)(M).t) ->
                      ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                    val ( !! ) : '-> 'T1(T)(M).t
                    val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( >>= ) :
                      'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val ( >>| ) :
                      'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          'T1(T)(M).t ->
                          ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val ( >>| ) :
                          'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                      end
                    val bind :
                      'T1(T)(M).t ->
                      f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val return : '-> 'T1(T)(M).t
                    val map : 'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                    val join : 'T1(T)(M).t T1(T)(M).t -> 'T1(T)(M).t
                    val ignore_m : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                    val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                    val all_ignore :
                      Monoid.Unit.t T1(T)(M).t list ->
                      Monoid.Unit.t T1(T)(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T1(T)(M).t
                        val ( >>= ) :
                          'T1(T)(M).t ->
                          ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val ( >>| ) :
                          'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                        module Let_syntax :
                          sig
                            val return : '-> 'T1(T)(M).t
                            val bind :
                              'T1(T)(M).t ->
                              f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val map :
                              'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                            val both :
                              'T1(T)(M).t ->
                              'T1(T)(M).t -> ('a * 'b) T1(T)(M).t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Syntax :
                      sig
                        val ( >>= ) :
                          'T1(T)(M).t ->
                          ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val ( >>| ) :
                          'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                        val ( >=> ) :
                          ('-> 'T1(T)(M).t) ->
                          ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                        val ( !! ) : '-> 'T1(T)(M).t
                        val ( !$ ) :
                          ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                      end
                  end
              module Make2 :
                functor (M : Monad->
                  sig
                    val lift : 'M.t -> ('a, 'e) T2(M).t
                    val run : ('a, 'e) T2(M).t -> ('a, 'e) T2(M).e
                    val read : Monoid.Unit.t -> ('e, 'e) T2(M).t
                    val void :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    module Fn :
                      sig
                        val id : '-> ('a, 'e) T2(M).t
                        val ignore :
                          ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                        val nothing :
                          Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
                        val non :
                          ('-> (bool, 'e) T2(M).t) ->
                          '-> (bool, 'e) T2(M).t
                        val apply_n_times :
                          n:Monoid.Int.t ->
                          ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                        val compose :
                          ('-> ('c, 'e) T2(M).t) ->
                          ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                      end
                    module Pair :
                      sig
                        val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                        val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
                      end
                    module Triple :
                      sig
                        val fst :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                        val snd :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val trd :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
                      end
                    module Lift :
                      sig
                        val nullary : '-> ('a, 'e) T2(M).t
                        val unary :
                          ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val binary :
                          ('-> '-> 'c) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                        val ternary :
                          ('-> '-> '-> 'd) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t ->
                          ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                        val quaternary :
                          ('-> '-> '-> '-> 'e) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                        val quinary :
                          ('-> '-> '-> '-> '-> 'f) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t ->
                          ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                      end
                    module Exn :
                      sig
                        val expect :
                          ?finally:(Monoid.Unit.t ->
                                    (Monoid.Unit.t, 's) T2(M).t) ->
                          f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
                          catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
                      end
                    module Collection :
                      sig
                        module type S =
                          sig
                            type 'a t
                            val all :
                              ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                            val all_ignore :
                              ('a, 'e) T2(M).t t ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val sequence :
                              (Monoid.Unit.t, 'e) T2(M).t t ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val map :
                              'a t ->
                              f:('-> ('b, 'e) T2(M).t) ->
                              ('b t, 'e) T2(M).t
                            val iter :
                              'a t ->
                              f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val fold :
                              'a t ->
                              init:'->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              ('b, 'e) T2(M).t
                            val fold_left :
                              'a t ->
                              init:'->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              ('b, 'e) T2(M).t
                            val fold_right :
                              'a t ->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              init:'-> ('b, 'e) T2(M).t
                            val reduce :
                              'a t ->
                              f:('-> '-> ('a, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val exists :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (bool, 'e) T2(M).t
                            val for_all :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (bool, 'e) T2(M).t
                            val count :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (Monoid.Int.t, 'e) T2(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b t ->
                              f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                            val find :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val find_map :
                              'a t ->
                              f:('-> ('Option.t, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val filter :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              ('a t, 'e) T2(M).t
                            val filter_map :
                              'a t ->
                              f:('-> ('Option.t, 'e) T2(M).t) ->
                              ('b t, 'e) T2(M).t
                          end
                        module Eager :
                          functor (T : Collection.Eager->
                            sig
                              val all :
                                ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                              val all_ignore :
                                ('a, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val sequence :
                                (Monoid.Unit.t, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val map :
                                'T.t ->
                                f:('-> ('b, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val iter :
                                'T.t ->
                                f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                init:'-> ('b, 'e) T2(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> ('a, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val exists :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val for_all :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val count :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (Monoid.Int.t, 'e) T2(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> ('a, 'e) T2(M).t) ->
                                ('a, 'e) T2(M).t
                              val find :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val find_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val filter :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                            end
                        module Delay :
                          functor (T : Collection.Delay->
                            sig
                              val all :
                                ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                              val all_ignore :
                                ('a, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val sequence :
                                (Monoid.Unit.t, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val map :
                                'T.t ->
                                f:('-> ('b, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val iter :
                                'T.t ->
                                f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                init:'-> ('b, 'e) T2(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> ('a, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val exists :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val for_all :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val count :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (Monoid.Int.t, 'e) T2(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> ('a, 'e) T2(M).t) ->
                                ('a, 'e) T2(M).t
                              val find :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val find_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val filter :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                            end
                      end
                    module List :
                      sig
                        val all :
                          ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t list ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t list ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'a list ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                        val iter :
                          'a list ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'a list ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'a list ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'a list ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'a list ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b list ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'a list ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('a list, 'e) T2(M).t
                        val filter_map :
                          'a list ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('b list, 'e) T2(M).t
                      end
                    module Seq :
                      sig
                        val all :
                          ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t
                          Core_kernel.Std.Sequence.t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('b, 'e) T2(M).t) ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                        val iter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'Core_kernel.Std.Sequence.t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'Core_kernel.Std.Sequence.t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                        val filter_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                      end
                    val ( >=> ) :
                      ('-> ('b, 'e) T2(M).t) ->
                      ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                    val ( !! ) : '-> ('a, 'e) T2(M).t
                    val ( !$ ) :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) T2(M).t
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                        module Let_syntax :
                          sig
                            val return : '-> ('a, 'b) T2(M).t
                            val bind :
                              ('a, 'e) T2(M).t ->
                              f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                            val map :
                              ('a, 'e) T2(M).t ->
                              f:('-> 'b) -> ('b, 'e) T2(M).t
                            val both :
                              ('a, 'e) T2(M).t ->
                              ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                      end
                    val bind :
                      ('a, 'e) T2(M).t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val return : '-> ('a, 'b) T2(M).t
                    val map :
                      ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                    val join :
                      (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val ignore_m :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                    val all_ignore :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    module Syntax :
                      sig
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                        val ( >=> ) :
                          ('-> ('b, 'e) T2(M).t) ->
                          ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                        val ( !! ) : '-> ('a, 'e) T2(M).t
                        val ( !$ ) :
                          ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t ->
                          ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t ->
                          ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                      end
                  end
            end
          module State :
            sig
              type ('a, 'e) storage
              type ('a, 'e) state
              module type S =
                sig
                  type 'a t
                  type 'a m
                  type 'a e
                  val lift : 'a m -> 'a t
                  val run : 'a t -> 'a e
                  val void : 'a t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
                  val forever : 'a t -> 'b t
                  module Fn :
                    sig
                      val id : '-> 'a t
                      val ignore : 'a t -> Monoid.Unit.t t
                      val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                      val non : ('-> bool t) -> '-> bool t
                      val apply_n_times :
                        n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                      val compose :
                        ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                    end
                  module Pair :
                    sig
                      val fst : ('a * 'b) t -> 'a t
                      val snd : ('a * 'b) t -> 'b t
                    end
                  module Triple :
                    sig
                      val fst : ('a * 'b * 'c) t -> 'a t
                      val snd : ('a * 'b * 'c) t -> 'b t
                      val trd : ('a * 'b * 'c) t -> 'c t
                    end
                  module Lift :
                    sig
                      val nullary : '-> 'a t
                      val unary : ('-> 'b) -> 'a t -> 'b t
                      val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ternary :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val quaternary :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val quinary :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                  module Exn :
                    sig
                      val expect :
                        ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                        f:(Monoid.Unit.t -> 'a t) ->
                        catch:(exn -> 'a t) -> 'a t
                    end
                  module Collection :
                    sig
                      module type S =
                        sig
                          type 'a t
                          val all : 'a t t -> 'a t t
                          val all_ignore : 'a t t -> Monoid.Unit.t t
                          val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                          val map : 'a t -> f:('-> 'b t) -> 'b t t
                          val iter :
                            'a t ->
                            f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                          val fold :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_left :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_right :
                            'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                          val reduce :
                            'a t -> f:('-> '-> 'a t) -> 'Option.t t
                          val exists : 'a t -> f:('-> bool t) -> bool t
                          val for_all : 'a t -> f:('-> bool t) -> bool t
                          val count :
                            'a t -> f:('-> bool t) -> Monoid.Int.t t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b t -> f:('-> 'a t) -> 'a t
                          val find :
                            'a t -> f:('-> bool t) -> 'Option.t t
                          val find_map :
                            'a t -> f:('-> 'Option.t t) -> 'Option.t t
                          val filter : 'a t -> f:('-> bool t) -> 'a t t
                          val filter_map :
                            'a t -> f:('-> 'Option.t t) -> 'b t t
                        end
                      module Eager :
                        functor (T : Collection.Eager->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'Option.t t
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t t) -> 'Option.t t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'Option.t t) -> 'T.t t
                          end
                      module Delay :
                        functor (T : Collection.Delay->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'Option.t t
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t t) -> 'Option.t t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'Option.t t) -> 'T.t t
                          end
                    end
                  module List :
                    sig
                      val all : 'a t List.t -> 'List.t t
                      val all_ignore : 'a t List.t -> Monoid.Unit.t t
                      val sequence :
                        Monoid.Unit.t t List.t -> Monoid.Unit.t t
                      val map : 'List.t -> f:('-> 'b t) -> 'List.t t
                      val iter :
                        'List.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'List.t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'List.t -> f:('-> bool t) -> bool t
                      val for_all : 'List.t -> f:('-> bool t) -> bool t
                      val count :
                        'List.t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'List.t -> f:('-> 'a t) -> 'a t
                      val find :
                        'List.t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'List.t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter :
                        'List.t -> f:('-> bool t) -> 'List.t t
                      val filter_map :
                        'List.t -> f:('-> 'Option.t t) -> 'List.t t
                    end
                  module Seq :
                    sig
                      val all : 'a t Seq.t -> 'Seq.t t
                      val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
                      val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
                      val iter :
                        'Seq.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'Seq.t -> f:('-> bool t) -> bool t
                      val for_all : 'Seq.t -> f:('-> bool t) -> bool t
                      val count :
                        'Seq.t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'Seq.t -> f:('-> 'a t) -> 'a t
                      val find :
                        'Seq.t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
                      val filter_map :
                        'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
                    end
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Monad_infix :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                    end
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val return : '-> 'a t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val join : 'a t t -> 'a t
                  val ignore_m : 'a t -> Monoid.Unit.t t
                  val all : 'a t list -> 'a list t
                  val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      module Let_syntax :
                        sig
                          val return : '-> 'a t
                          val bind : 'a t -> f:('-> 'b t) -> 'b t
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val both : 'a t -> 'b t -> ('a * 'b) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Syntax :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      val ( >=> ) :
                        ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                      val ( !! ) : '-> 'a t
                      val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                      val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                  type env
                  val put : Monads.Std.Monad.State.S.env -> unit t
                  val get : unit -> Monads.Std.Monad.State.S.env t
                  val gets : (Monads.Std.Monad.State.S.env -> 'r) -> 'r t
                  val update :
                    (Monads.Std.Monad.State.S.env ->
                     Monads.Std.Monad.State.S.env) ->
                    unit t
                end
              module type S2 =
                sig
                  type ('a, 'e) t
                  type 'a m
                  type ('a, 'e) e
                  val lift : 'a m -> ('a, 'e) t
                  val run : ('a, 'e) t -> ('a, 'e) e
                  val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val forever : ('a, 'e) t -> ('b, 'e) t
                  module Fn :
                    sig
                      val id : '-> ('a, 'e) t
                      val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                      val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                      val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                      val apply_n_times :
                        n:Monoid.Int.t ->
                        ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                      val compose :
                        ('-> ('c, 'e) t) ->
                        ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                    end
                  module Pair :
                    sig
                      val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                      val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                    end
                  module Triple :
                    sig
                      val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                      val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                      val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                    end
                  module Lift :
                    sig
                      val nullary : '-> ('a, 'e) t
                      val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                      val binary :
                        ('-> '-> 'c) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                      val ternary :
                        ('-> '-> '-> 'd) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                      val quaternary :
                        ('-> '-> '-> '-> 'e) ->
                        ('a, 's) t ->
                        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                      val quinary :
                        ('-> '-> '-> '-> '-> 'f) ->
                        ('a, 's) t ->
                        ('b, 's) t ->
                        ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                    end
                  module Exn :
                    sig
                      val expect :
                        ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                        f:(Monoid.Unit.t -> ('a, 's) t) ->
                        catch:(exn -> ('a, 's) t) -> ('a, 's) t
                    end
                  module Collection :
                    sig
                      module type S =
                        sig
                          type 'a t
                          val all : ('a, 'e) t t -> ('a t, 'e) t
                          val all_ignore :
                            ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
                          val sequence :
                            (Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
                          val map :
                            'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                          val iter :
                            'a t ->
                            f:('-> (Monoid.Unit.t, 'e) t) ->
                            (Monoid.Unit.t, 'e) t
                          val fold :
                            'a t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_left :
                            'a t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_right :
                            'a t ->
                            f:('-> '-> ('b, 'e) t) ->
                            init:'-> ('b, 'e) t
                          val reduce :
                            'a t ->
                            f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                          val exists :
                            'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val for_all :
                            'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val count :
                            'a t ->
                            f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                          val find :
                            'a t ->
                            f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                          val find_map :
                            'a t ->
                            f:('-> ('Option.t, 'e) t) ->
                            ('Option.t, 'e) t
                          val filter :
                            'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                          val filter_map :
                            'a t ->
                            f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                        end
                      module Eager :
                        functor (T : Collection.Eager->
                          sig
                            val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                            val all_ignore :
                              ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                            val sequence :
                              (Monoid.Unit.t, 'e) t T.t ->
                              (Monoid.Unit.t, 'e) t
                            val map :
                              'T.t ->
                              f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                            val iter :
                              'T.t ->
                              f:('-> (Monoid.Unit.t, 'e) t) ->
                              (Monoid.Unit.t, 'e) t
                            val fold :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_left :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> ('b, 'e) t) ->
                              init:'-> ('b, 'e) t
                            val reduce :
                              'T.t ->
                              f:('-> '-> ('a, 'e) t) ->
                              ('Option.t, 'e) t
                            val exists :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val for_all :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val count :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                            val find :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                            val find_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) ->
                              ('Option.t, 'e) t
                            val filter :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                            val filter_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                          end
                      module Delay :
                        functor (T : Collection.Delay->
                          sig
                            val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                            val all_ignore :
                              ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                            val sequence :
                              (Monoid.Unit.t, 'e) t T.t ->
                              (Monoid.Unit.t, 'e) t
                            val map :
                              'T.t ->
                              f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                            val iter :
                              'T.t ->
                              f:('-> (Monoid.Unit.t, 'e) t) ->
                              (Monoid.Unit.t, 'e) t
                            val fold :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_left :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> ('b, 'e) t) ->
                              init:'-> ('b, 'e) t
                            val reduce :
                              'T.t ->
                              f:('-> '-> ('a, 'e) t) ->
                              ('Option.t, 'e) t
                            val exists :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val for_all :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val count :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                            val find :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                            val find_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) ->
                              ('Option.t, 'e) t
                            val filter :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                            val filter_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                          end
                    end
                  module List :
                    sig
                      val all : ('a, 'e) t List.t -> ('List.t, 'e) t
                      val all_ignore :
                        ('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                      val map :
                        'List.t ->
                        f:('-> ('b, 'e) t) -> ('List.t, 'e) t
                      val iter :
                        'List.t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'List.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'List.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'List.t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'List.t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'List.t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'List.t ->
                        f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'List.t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'List.t ->
                        f:('-> (bool, 'e) t) -> ('List.t, 'e) t
                      val filter_map :
                        'List.t ->
                        f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
                    end
                  module Seq :
                    sig
                      val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
                      val all_ignore :
                        ('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                      val map :
                        'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
                      val iter :
                        'Seq.t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'Seq.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'Seq.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'Seq.t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'Seq.t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'Seq.t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'Seq.t ->
                        f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'Seq.t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'Seq.t ->
                        f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
                      val filter_map :
                        'Seq.t ->
                        f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
                    end
                  val ( >=> ) :
                    ('-> ('b, 'e) t) ->
                    ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                  val ( !! ) : '-> ('a, 'e) t
                  val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      module Let_syntax :
                        sig
                          val return : '-> ('a, 'b) t
                          val bind :
                            ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                          val both :
                            ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Monad_infix :
                    sig
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                    end
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val return : '-> ('a, 'b) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                  val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val all : ('a, 'e) t list -> ('a list, 'e) t
                  val all_ignore :
                    (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                  module Syntax :
                    sig
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      val ( >=> ) :
                        ('-> ('b, 'e) t) ->
                        ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                      val ( !! ) : '-> ('a, 'e) t
                      val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                      val ( !$$ ) :
                        ('-> '-> 'c) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        ('a, 's) t ->
                        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        ('a, 's) t ->
                        ('b, 's) t ->
                        ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                    end
                  val put : '-> (unit, 's) t
                  val get : unit -> ('s, 's) t
                  val gets : ('-> 'r) -> ('r, 's) t
                  val update : ('-> 's) -> (unit, 's) t
                end
              module Multi :
                sig
                  type status = [ `Current | `Dead | `Live ]
                  type 'a contexts
                  type id
                  module Id :
                    sig
                      type t = id
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                      val of_string : Monoid.String.t -> t
                      val to_string : t -> Monoid.String.t
                      val ( >= ) : t -> t -> bool
                      val ( <= ) : t -> t -> bool
                      val ( = ) : t -> t -> bool
                      val ( > ) : t -> t -> bool
                      val ( < ) : t -> t -> bool
                      val ( <> ) : t -> t -> bool
                      val equal : t -> t -> bool
                      val compare : t -> t -> Monoid.Int.t
                      val min : t -> t -> t
                      val max : t -> t -> t
                      val ascending : t -> t -> Monoid.Int.t
                      val descending : t -> t -> Monoid.Int.t
                      val between : t -> low:t -> high:t -> bool
                      val clamp_exn : t -> min:t -> max:t -> t
                      val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                      type comparator_witness
                      val validate_lbound :
                        min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                      val validate_ubound :
                        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                      val validate_bound :
                        min:t Base__.Maybe_bound.t ->
                        max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                      module Replace_polymorphic_compare :
                        sig
                          val ( >= ) : t -> t -> bool
                          val ( <= ) : t -> t -> bool
                          val ( = ) : t -> t -> bool
                          val ( > ) : t -> t -> bool
                          val ( < ) : t -> t -> bool
                          val ( <> ) : t -> t -> bool
                          val equal : t -> t -> bool
                          val compare : t -> t -> Monoid.Int.t
                          val min : t -> t -> t
                          val max : t -> t -> t
                        end
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                      module Map :
                        sig
                          module Key :
                            sig
                              type t = id
                              val t_of_sexp : Sexplib.Sexp.t -> t
                              val sexp_of_t : t -> Sexplib.Sexp.t
                              val bin_t : t Bin_prot.Type_class.t
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (Core_kernel__.Import.int -> t)
                                Bin_prot.Read.reader
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_shape_t : Bin_prot.Shape.t
                              type comparator_witness = comparator_witness
                              val comparator :
                                (t, comparator_witness)
                                Core_kernel__.Comparator.comparator
                            end
                          module Tree :
                            sig
                              type 'a t =
                                  (id, 'a, comparator_witness)
                                  Core_kernel__.Core_map_intf.Tree.t
                              val empty : 'a t
                              val singleton : id -> '-> 'a t
                              val of_alist :
                                (id * 'a) List.t ->
                                [ `Duplicate_key of id | `Ok of 'a t ]
                              val of_alist_or_error :
                                (id * 'a) List.t -> 'a t Base__.Or_error.t
                              val of_alist_exn : (id * 'a) List.t -> 'a t
                              val of_alist_multi :
                                (id * 'a) List.t -> 'List.t t
                              val of_alist_fold :
                                (id * 'a) List.t ->
                                init:'-> f:('-> '-> 'b) -> 'b t
                              val of_alist_reduce :
                                (id * 'a) List.t ->
                                f:('-> '-> 'a) -> 'a t
                              val of_sorted_array :
                                (id * 'a) array -> 'a t Base__.Or_error.t
                              val of_sorted_array_unchecked :
                                (id * 'a) array -> 'a t
                              val of_increasing_iterator_unchecked :
                                len:Monoid.Int.t ->
                                f:(Monoid.Int.t -> id * 'a) -> 'a t
                              val of_iteri :
                                iteri:(f:(key:id -> data:'-> Monoid.Unit.t) ->
                                       Monoid.Unit.t) ->
                                [ `Duplicate_key of id | `Ok of 'v t ]
                              val of_tree : 'a t -> 'a t
                              val of_hashtbl_exn :
                                (id, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                              val gen :
                                id Core_kernel__.Quickcheck.Generator.t ->
                                'Core_kernel__.Quickcheck.Generator.t ->
                                'a t Core_kernel__.Quickcheck.Generator.t
                              val invariants : 'a t -> bool
                              val is_empty : 'a t -> bool
                              val length : 'a t -> Monoid.Int.t
                              val add : 'a t -> key:id -> data:'-> 'a t
                              val add_multi :
                                'List.t t ->
                                key:id -> data:'-> 'List.t t
                              val remove_multi :
                                'List.t t -> id -> 'List.t t
                              val change :
                                'a t ->
                                id -> f:('Option.t -> 'Option.t) -> 'a t
                              val update :
                                'a t -> id -> f:('Option.t -> 'a) -> 'a t
                              val find : 'a t -> id -> 'Option.t
                              val find_exn : 'a t -> id -> 'a
                              val remove : 'a t -> id -> 'a t
                              val mem : 'a t -> id -> bool
                              val iter_keys :
                                'a t ->
                                f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
                              val iter :
                                'a t ->
                                f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                              val iteri :
                                'a t ->
                                f:(key:id -> data:'-> Monoid.Unit.t) ->
                                Monoid.Unit.t
                              val iter2 :
                                'a t ->
                                'b t ->
                                f:(key:id ->
                                   data:[ `Both of 'a * 'b
                                        | `Left of 'a
                                        | `Right of 'b ] ->
                                   Monoid.Unit.t) ->
                                Monoid.Unit.t
                              val map : 'a t -> f:('-> 'b) -> 'b t
                              val mapi :
                                'a t -> f:(key:id -> data:'-> 'b) -> 'b t
                              val fold :
                                'a t ->
                                init:'->
                                f:(key:id -> data:'-> '-> 'b) -> 'b
                              val fold_right :
                                'a t ->
                                init:'->
                                f:(key:id -> data:'-> '-> 'b) -> 'b
                              val fold2 :
                                'a t ->
                                'b t ->
                                init:'->
                                f:(key:id ->
                                   data:[ `Both of 'a * 'b
                                        | `Left of 'a
                                        | `Right of 'b ] ->
                                   '-> 'c) ->
                                'c
                              val filter_keys :
                                'a t -> f:(id -> bool) -> 'a t
                              val filter : 'a t -> f:('-> bool) -> 'a t
                              val filteri :
                                'a t -> f:(key:id -> data:'-> bool) -> 'a t
                              val filter_map :
                                'a t -> f:('-> 'Option.t) -> 'b t
                              val filter_mapi :
                                'a t ->
                                f:(key:id -> data:'-> 'Option.t) -> 'b t
                              val partition_mapi :
                                'a t ->
                                f:(key:id ->
                                   data:'-> [ `Fst of '| `Snd of 'c ]) ->
                                'b t * 'c t
                              val partition_map :
                                'a t ->
                                f:('-> [ `Fst of '| `Snd of 'c ]) ->
                                'b t * 'c t
                              val partitioni_tf :
                                'a t ->
                                f:(key:id -> data:'-> bool) -> 'a t * 'a t
                              val partition_tf :
                                'a t -> f:('-> bool) -> 'a t * 'a t
                              val compare_direct :
                                ('-> '-> Monoid.Int.t) ->
                                'a t -> 'a t -> Monoid.Int.t
                              val equal :
                                ('-> '-> bool) -> 'a t -> 'a t -> bool
                              val keys : 'a t -> id List.t
                              val data : 'a t -> 'List.t
                              val to_alist :
                                ?key_order:[ `Decreasing | `Increasing ] ->
                                'a t -> (id * 'a) List.t
                              val validate :
                                name:(id -> Monoid.String.t) ->
                                'Base__.Validate.check ->
                                'a t Base__.Validate.check
                              val merge :
                                'a t ->
                                'b t ->
                                f:(key:id ->
                                   [ `Both of 'a * 'b
                                   | `Left of 'a
                                   | `Right of 'b ] -> 'Option.t) ->
                                'c t
                              val symmetric_diff :
                                'a t ->
                                'a t ->
                                data_equal:('-> '-> bool) ->
                                (id, 'a)
                                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                                Base__.Sequence.t
                              val min_elt : 'a t -> (id * 'a) Option.t
                              val min_elt_exn : 'a t -> id * 'a
                              val max_elt : 'a t -> (id * 'a) Option.t
                              val max_elt_exn : 'a t -> id * 'a
                              val for_all : 'a t -> f:('-> bool) -> bool
                              val for_alli :
                                'a t -> f:(key:id -> data:'-> bool) -> bool
                              val exists : 'a t -> f:('-> bool) -> bool
                              val existsi :
                                'a t -> f:(key:id -> data:'-> bool) -> bool
                              val count :
                                'a t -> f:('-> bool) -> Monoid.Int.t
                              val counti :
                                'a t ->
                                f:(key:id -> data:'-> bool) -> Monoid.Int.t
                              val split :
                                'a t ->
                                id -> 'a t * (id * 'a) Option.t * 'a t
                              val append :
                                lower_part:'a t ->
                                upper_part:'a t ->
                                [ `Ok of 'a t | `Overlapping_key_ranges ]
                              val subrange :
                                'a t ->
                                lower_bound:id Base__.Maybe_bound.t ->
                                upper_bound:id Base__.Maybe_bound.t -> 'a t
                              val fold_range_inclusive :
                                'a t ->
                                min:id ->
                                max:id ->
                                init:'->
                                f:(key:id -> data:'-> '-> 'b) -> 'b
                              val range_to_alist :
                                'a t -> min:id -> max:id -> (id * 'a) List.t
                              val closest_key :
                                'a t ->
                                [ `Greater_or_equal_to
                                | `Greater_than
                                | `Less_or_equal_to
                                | `Less_than ] -> id -> (id * 'a) Option.t
                              val nth :
                                'a t -> Monoid.Int.t -> (id * 'a) Option.t
                              val nth_exn : 'a t -> Monoid.Int.t -> id * 'a
                              val rank : 'a t -> id -> Monoid.Int.t Option.t
                              val to_tree : 'a t -> 'a t
                              val to_sequence :
                                ?order:[ `Decreasing_key | `Increasing_key ] ->
                                ?keys_greater_or_equal_to:id ->
                                ?keys_less_or_equal_to:id ->
                                'a t -> (id * 'a) Base__.Sequence.t
                              val obs :
                                id Core_kernel__.Quickcheck.Observer.t ->
                                'Core_kernel__.Quickcheck.Observer.t ->
                                'v t Core_kernel__.Quickcheck.Observer.t
                              val shrinker :
                                id Core_kernel__.Quickcheck.Shrinker.t ->
                                'Core_kernel__.Quickcheck.Shrinker.t ->
                                'v t Core_kernel__.Quickcheck.Shrinker.t
                              module Provide_of_sexp :
                                functor
                                  (K : sig
                                         val t_of_sexp : Sexplib.Sexp.t -> id
                                       end->
                                  sig
                                    val t_of_sexp :
                                      (Sexplib.Sexp.t -> 'v_x__017_) ->
                                      Sexplib.Sexp.t -> 'v_x__017_ t
                                  end
                              val t_of_sexp :
                                (Base__.Sexplib.Sexp.t -> 'a) ->
                                Base__.Sexplib.Sexp.t -> 'a t
                              val sexp_of_t :
                                ('-> Base__.Sexplib.Sexp.t) ->
                                'a t -> Base__.Sexplib.Sexp.t
                            end
                          type 'a t =
                              (id, 'a, comparator_witness)
                              Core_kernel__.Core_map_intf.Map.t
                          val compare :
                            ('-> '-> Core_kernel__.Import.int) ->
                            'a t -> 'a t -> Core_kernel__.Import.int
                          val empty : 'a t
                          val singleton : id -> '-> 'a t
                          val of_alist :
                            (id * 'a) List.t ->
                            [ `Duplicate_key of id | `Ok of 'a t ]
                          val of_alist_or_error :
                            (id * 'a) List.t -> 'a t Base__.Or_error.t
                          val of_alist_exn : (id * 'a) List.t -> 'a t
                          val of_alist_multi :
                            (id * 'a) List.t -> 'List.t t
                          val of_alist_fold :
                            (id * 'a) List.t ->
                            init:'-> f:('-> '-> 'b) -> 'b t
                          val of_alist_reduce :
                            (id * 'a) List.t -> f:('-> '-> 'a) -> 'a t
                          val of_sorted_array :
                            (id * 'a) array -> 'a t Base__.Or_error.t
                          val of_sorted_array_unchecked :
                            (id * 'a) array -> 'a t
                          val of_increasing_iterator_unchecked :
                            len:Monoid.Int.t ->
                            f:(Monoid.Int.t -> id * 'a) -> 'a t
                          val of_iteri :
                            iteri:(f:(key:id -> data:'-> Monoid.Unit.t) ->
                                   Monoid.Unit.t) ->
                            [ `Duplicate_key of id | `Ok of 'v t ]
                          val of_tree : 'Tree.t -> 'a t
                          val of_hashtbl_exn :
                            (id, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                          val gen :
                            id Core_kernel__.Quickcheck.Generator.t ->
                            'Core_kernel__.Quickcheck.Generator.t ->
                            'a t Core_kernel__.Quickcheck.Generator.t
                          val invariants : 'a t -> bool
                          val is_empty : 'a t -> bool
                          val length : 'a t -> Monoid.Int.t
                          val add : 'a t -> key:id -> data:'-> 'a t
                          val add_multi :
                            'List.t t -> key:id -> data:'-> 'List.t t
                          val remove_multi : 'List.t t -> id -> 'List.t t
                          val change :
                            'a t ->
                            id -> f:('Option.t -> 'Option.t) -> 'a t
                          val update :
                            'a t -> id -> f:('Option.t -> 'a) -> 'a t
                          val find : 'a t -> id -> 'Option.t
                          val find_exn : 'a t -> id -> 'a
                          val remove : 'a t -> id -> 'a t
                          val mem : 'a t -> id -> bool
                          val iter_keys :
                            'a t -> f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
                          val iter :
                            'a t -> f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                          val iteri :
                            'a t ->
                            f:(key:id -> data:'-> Monoid.Unit.t) ->
                            Monoid.Unit.t
                          val iter2 :
                            'a t ->
                            'b t ->
                            f:(key:id ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               Monoid.Unit.t) ->
                            Monoid.Unit.t
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val mapi :
                            'a t -> f:(key:id -> data:'-> 'b) -> 'b t
                          val fold :
                            'a t ->
                            init:'->
                            f:(key:id -> data:'-> '-> 'b) -> 'b
                          val fold_right :
                            'a t ->
                            init:'->
                            f:(key:id -> data:'-> '-> 'b) -> 'b
                          val fold2 :
                            'a t ->
                            'b t ->
                            init:'->
                            f:(key:id ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               '-> 'c) ->
                            'c
                          val filter_keys : 'a t -> f:(id -> bool) -> 'a t
                          val filter : 'a t -> f:('-> bool) -> 'a t
                          val filteri :
                            'a t -> f:(key:id -> data:'-> bool) -> 'a t
                          val filter_map :
                            'a t -> f:('-> 'Option.t) -> 'b t
                          val filter_mapi :
                            'a t ->
                            f:(key:id -> data:'-> 'Option.t) -> 'b t
                          val partition_mapi :
                            'a t ->
                            f:(key:id ->
                               data:'-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partition_map :
                            'a t ->
                            f:('-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partitioni_tf :
                            'a t ->
                            f:(key:id -> data:'-> bool) -> 'a t * 'a t
                          val partition_tf :
                            'a t -> f:('-> bool) -> 'a t * 'a t
                          val compare_direct :
                            ('-> '-> Monoid.Int.t) ->
                            'a t -> 'a t -> Monoid.Int.t
                          val equal :
                            ('-> '-> bool) -> 'a t -> 'a t -> bool
                          val keys : 'a t -> id List.t
                          val data : 'a t -> 'List.t
                          val to_alist :
                            ?key_order:[ `Decreasing | `Increasing ] ->
                            'a t -> (id * 'a) List.t
                          val validate :
                            name:(id -> Monoid.String.t) ->
                            'Base__.Validate.check ->
                            'a t Base__.Validate.check
                          val merge :
                            'a t ->
                            'b t ->
                            f:(key:id ->
                               [ `Both of 'a * 'b
                               | `Left of 'a
                               | `Right of 'b ] -> 'Option.t) ->
                            'c t
                          val symmetric_diff :
                            'a t ->
                            'a t ->
                            data_equal:('-> '-> bool) ->
                            (id, 'a)
                            Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                            Base__.Sequence.t
                          val min_elt : 'a t -> (id * 'a) Option.t
                          val min_elt_exn : 'a t -> id * 'a
                          val max_elt : 'a t -> (id * 'a) Option.t
                          val max_elt_exn : 'a t -> id * 'a
                          val for_all : 'a t -> f:('-> bool) -> bool
                          val for_alli :
                            'a t -> f:(key:id -> data:'-> bool) -> bool
                          val exists : 'a t -> f:('-> bool) -> bool
                          val existsi :
                            'a t -> f:(key:id -> data:'-> bool) -> bool
                          val count : 'a t -> f:('-> bool) -> Monoid.Int.t
                          val counti :
                            'a t ->
                            f:(key:id -> data:'-> bool) -> Monoid.Int.t
                          val split :
                            'a t -> id -> 'a t * (id * 'a) Option.t * 'a t
                          val append :
                            lower_part:'a t ->
                            upper_part:'a t ->
                            [ `Ok of 'a t | `Overlapping_key_ranges ]
                          val subrange :
                            'a t ->
                            lower_bound:id Base__.Maybe_bound.t ->
                            upper_bound:id Base__.Maybe_bound.t -> 'a t
                          val fold_range_inclusive :
                            'a t ->
                            min:id ->
                            max:id ->
                            init:'->
                            f:(key:id -> data:'-> '-> 'b) -> 'b
                          val range_to_alist :
                            'a t -> min:id -> max:id -> (id * 'a) List.t
                          val closest_key :
                            'a t ->
                            [ `Greater_or_equal_to
                            | `Greater_than
                            | `Less_or_equal_to
                            | `Less_than ] -> id -> (id * 'a) Option.t
                          val nth :
                            'a t -> Monoid.Int.t -> (id * 'a) Option.t
                          val nth_exn : 'a t -> Monoid.Int.t -> id * 'a
                          val rank : 'a t -> id -> Monoid.Int.t Option.t
                          val to_tree : 'a t -> 'Tree.t
                          val to_sequence :
                            ?order:[ `Decreasing_key | `Increasing_key ] ->
                            ?keys_greater_or_equal_to:id ->
                            ?keys_less_or_equal_to:id ->
                            'a t -> (id * 'a) Base__.Sequence.t
                          val obs :
                            id Core_kernel__.Quickcheck.Observer.t ->
                            'Core_kernel__.Quickcheck.Observer.t ->
                            'v t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            id Core_kernel__.Quickcheck.Shrinker.t ->
                            'Core_kernel__.Quickcheck.Shrinker.t ->
                            'v t Core_kernel__.Quickcheck.Shrinker.t
                          module Provide_of_sexp :
                            functor
                              (Key : sig
                                       val t_of_sexp : Sexplib.Sexp.t -> id
                                     end->
                              sig
                                val t_of_sexp :
                                  (Sexplib.Sexp.t -> 'v_x__018_) ->
                                  Sexplib.Sexp.t -> 'v_x__018_ t
                              end
                          module Provide_bin_io :
                            functor
                              (Key : sig
                                       val bin_t : id Bin_prot.Type_class.t
                                       val bin_read_t :
                                         id Bin_prot.Read.reader
                                       val __bin_read_t__ :
                                         (Core_kernel__.Import.int -> id)
                                         Bin_prot.Read.reader
                                       val bin_reader_t :
                                         id Bin_prot.Type_class.reader
                                       val bin_size_t :
                                         id Bin_prot.Size.sizer
                                       val bin_write_t :
                                         id Bin_prot.Write.writer
                                       val bin_writer_t :
                                         id Bin_prot.Type_class.writer
                                       val bin_shape_t : Bin_prot.Shape.t
                                     end->
                              sig
                                val bin_shape_t :
                                  Bin_prot.Shape.t -> Bin_prot.Shape.t
                                val bin_size_t :
                                  ('a, 'a t) Bin_prot.Size.sizer1
                                val bin_write_t :
                                  ('a, 'a t) Bin_prot.Write.writer1
                                val bin_read_t :
                                  ('a, 'a t) Bin_prot.Read.reader1
                                val __bin_read_t__ :
                                  ('a, Monoid.Int.t -> 'a t)
                                  Bin_prot.Read.reader1
                                val bin_writer_t :
                                  ('a, 'a t) Bin_prot.Type_class.S1.writer
                                val bin_reader_t :
                                  ('a, 'a t) Bin_prot.Type_class.S1.reader
                                val bin_t :
                                  ('a, 'a t) Bin_prot.Type_class.S1.t
                              end
                          module Provide_hash :
                            functor
                              (Key : sig
                                       val hash_fold_t :
                                         Base__.Hash.state ->
                                         id -> Base__.Hash.state
                                     end->
                              sig
                                val hash_fold_t :
                                  (Ppx_hash_lib.Std.Hash.state ->
                                   '-> Ppx_hash_lib.Std.Hash.state) ->
                                  Ppx_hash_lib.Std.Hash.state ->
                                  'a t -> Ppx_hash_lib.Std.Hash.state
                              end
                          val t_of_sexp :
                            (Base__.Sexplib.Sexp.t -> 'a) ->
                            Base__.Sexplib.Sexp.t -> 'a t
                          val sexp_of_t :
                            ('-> Base__.Sexplib.Sexp.t) ->
                            'a t -> Base__.Sexplib.Sexp.t
                          val bin_shape_t :
                            Bin_prot.Shape.t -> Bin_prot.Shape.t
                          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                          val __bin_read_t__ :
                            ('a, Monoid.Int.t -> 'a t) Bin_prot.Read.reader1
                          val bin_writer_t :
                            ('a, 'a t) Bin_prot.Type_class.S1.writer
                          val bin_reader_t :
                            ('a, 'a t) Bin_prot.Type_class.S1.reader
                          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                        end
                      module Set :
                        sig
                          module Elt :
                            sig
                              type t = id
                              val bin_t : t Bin_prot.Type_class.t
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (Core_kernel__.Import.int -> t)
                                Bin_prot.Read.reader
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_shape_t : Bin_prot.Shape.t
                              val t_of_sexp : Sexplib.Sexp.t -> t
                              val sexp_of_t : t -> Sexplib.Sexp.t
                              type comparator_witness =
                                  Map.Key.comparator_witness
                              val comparator :
                                (t, comparator_witness)
                                Core_kernel__.Comparator.comparator
                            end
                          module Tree :
                            sig
                              type t =
                                  (id, comparator_witness)
                                  Core_kernel__.Core_set_intf.Tree.t
                              val compare :
                                t -> t -> Core_kernel__.Import.int
                              val length : t -> Monoid.Int.t
                              val is_empty : t -> bool
                              val iter :
                                t -> f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
                              val fold :
                                t ->
                                init:'accum ->
                                f:('accum -> id -> 'accum) -> 'accum
                              val fold_result :
                                t ->
                                init:'accum ->
                                f:('accum ->
                                   id -> ('accum, 'e) Base__.Result.t) ->
                                ('accum, 'e) Base__.Result.t
                              val exists : t -> f:(id -> bool) -> bool
                              val for_all : t -> f:(id -> bool) -> bool
                              val count : t -> f:(id -> bool) -> Monoid.Int.t
                              val sum :
                                (module Base__.Commutative_group.S with type t = 'sum) ->
                                t -> f:(id -> 'sum) -> 'sum
                              val find : t -> f:(id -> bool) -> id Option.t
                              val find_map :
                                t -> f:(id -> 'Option.t) -> 'Option.t
                              val to_list : t -> id List.t
                              val to_array : t -> id array
                              val invariants : t -> bool
                              val mem : t -> id -> bool
                              val add : t -> id -> t
                              val remove : t -> id -> t
                              val union : t -> t -> t
                              val inter : t -> t -> t
                              val diff : t -> t -> t
                              val symmetric_diff :
                                t ->
                                t ->
                                (id, id) Base__.Either.t Base__.Sequence.t
                              val compare_direct : t -> t -> Monoid.Int.t
                              val equal : t -> t -> bool
                              val is_subset : t -> of_:t -> bool
                              val subset : t -> t -> bool
                              val fold_until :
                                t ->
                                init:'->
                                f:('->
                                   id ->
                                   ('b, 'stop)
                                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                                ('b, 'stop)
                                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                              val fold_right :
                                t -> init:'-> f:(id -> '-> 'b) -> 'b
                              val iter2 :
                                t ->
                                t ->
                                f:([ `Both of id * id
                                   | `Left of id
                                   | `Right of id ] -> Monoid.Unit.t) ->
                                Monoid.Unit.t
                              val filter : t -> f:(id -> bool) -> t
                              val partition_tf : t -> f:(id -> bool) -> t * t
                              val elements : t -> id List.t
                              val min_elt : t -> id Option.t
                              val min_elt_exn : t -> id
                              val max_elt : t -> id Option.t
                              val max_elt_exn : t -> id
                              val choose : t -> id Option.t
                              val choose_exn : t -> id
                              val split : t -> id -> t * id Option.t * t
                              val group_by :
                                t -> equiv:(id -> id -> bool) -> t List.t
                              val find_exn : t -> f:(id -> bool) -> id
                              val find_index :
                                t -> Monoid.Int.t -> id Option.t
                              val nth : t -> Monoid.Int.t -> id Option.t
                              val remove_index : t -> Monoid.Int.t -> t
                              val to_tree : t -> t
                              val to_sequence :
                                ?order:[ `Decreasing | `Increasing ] ->
                                ?greater_or_equal_to:id ->
                                ?less_or_equal_to:id ->
                                t -> id Base__.Sequence.t
                              val merge_to_sequence :
                                ?order:[ `Decreasing | `Increasing ] ->
                                ?greater_or_equal_to:id ->
                                ?less_or_equal_to:id ->
                                t ->
                                t ->
                                (id, id)
                                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                                Base__.Sequence.t
                              val to_map :
                                t ->
                                f:(id -> 'data) ->
                                (id, 'data, comparator_witness)
                                Core_kernel__.Core_set_intf.Map.t
                              val obs :
                                id Core_kernel__.Quickcheck.Observer.t ->
                                t Core_kernel__.Quickcheck.Observer.t
                              val shrinker :
                                id Core_kernel__.Quickcheck.Shrinker.t ->
                                t Core_kernel__.Quickcheck.Shrinker.t
                              val empty : t
                              val singleton : id -> t
                              val union_list : t List.t -> t
                              val of_list : id List.t -> t
                              val of_array : id array -> t
                              val of_sorted_array :
                                id array -> t Base__.Or_error.t
                              val of_sorted_array_unchecked : id array -> t
                              val of_increasing_iterator_unchecked :
                                len:Monoid.Int.t ->
                                f:(Monoid.Int.t -> id) -> t
                              val stable_dedup_list : id List.t -> id List.t
                              val map :
                                ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                                f:('-> id) -> t
                              val filter_map :
                                ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                                f:('-> id Option.t) -> t
                              val of_tree : t -> t
                              val of_hash_set :
                                id Core_kernel__.Hash_set.t -> t
                              val of_hashtbl_keys :
                                (id, 'a) Core_kernel__.Core_hashtbl.t -> t
                              val of_map_keys :
                                (id, 'a, comparator_witness)
                                Core_kernel__.Core_set_intf.Map.t -> 
                                t
                              val gen :
                                id Core_kernel__.Quickcheck.Generator.t ->
                                t Core_kernel__.Quickcheck.Generator.t
                              module Provide_of_sexp :
                                functor
                                  (Elt : sig
                                           val t_of_sexp :
                                             Sexplib.Sexp.t -> id
                                         end->
                                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
                              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                            end
                          type t = (id, comparator_witness) Base.Set.t
                          val compare : t -> t -> Core_kernel__.Import.int
                          val length : t -> Monoid.Int.t
                          val is_empty : t -> bool
                          val iter :
                            t -> f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
                          val fold :
                            t ->
                            init:'accum ->
                            f:('accum -> id -> 'accum) -> 'accum
                          val fold_result :
                            t ->
                            init:'accum ->
                            f:('accum -> id -> ('accum, 'e) Base__.Result.t) ->
                            ('accum, 'e) Base__.Result.t
                          val exists : t -> f:(id -> bool) -> bool
                          val for_all : t -> f:(id -> bool) -> bool
                          val count : t -> f:(id -> bool) -> Monoid.Int.t
                          val sum :
                            (module Base__.Commutative_group.S with type t = 'sum) ->
                            t -> f:(id -> 'sum) -> 'sum
                          val find : t -> f:(id -> bool) -> id Option.t
                          val find_map :
                            t -> f:(id -> 'Option.t) -> 'Option.t
                          val to_list : t -> id List.t
                          val to_array : t -> id array
                          val invariants : t -> bool
                          val mem : t -> id -> bool
                          val add : t -> id -> t
                          val remove : t -> id -> t
                          val union : t -> t -> t
                          val inter : t -> t -> t
                          val diff : t -> t -> t
                          val symmetric_diff :
                            t ->
                            t -> (id, id) Base__.Either.t Base__.Sequence.t
                          val compare_direct : t -> t -> Monoid.Int.t
                          val equal : t -> t -> bool
                          val is_subset : t -> of_:t -> bool
                          val subset : t -> t -> bool
                          val fold_until :
                            t ->
                            init:'->
                            f:('->
                               id ->
                               ('b, 'stop)
                               Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                            ('b, 'stop)
                            Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                          val fold_right :
                            t -> init:'-> f:(id -> '-> 'b) -> 'b
                          val iter2 :
                            t ->
                            t ->
                            f:([ `Both of id * id
                               | `Left of id
                               | `Right of id ] -> Monoid.Unit.t) ->
                            Monoid.Unit.t
                          val filter : t -> f:(id -> bool) -> t
                          val partition_tf : t -> f:(id -> bool) -> t * t
                          val elements : t -> id List.t
                          val min_elt : t -> id Option.t
                          val min_elt_exn : t -> id
                          val max_elt : t -> id Option.t
                          val max_elt_exn : t -> id
                          val choose : t -> id Option.t
                          val choose_exn : t -> id
                          val split : t -> id -> t * id Option.t * t
                          val group_by :
                            t -> equiv:(id -> id -> bool) -> t List.t
                          val find_exn : t -> f:(id -> bool) -> id
                          val find_index : t -> Monoid.Int.t -> id Option.t
                          val nth : t -> Monoid.Int.t -> id Option.t
                          val remove_index : t -> Monoid.Int.t -> t
                          val to_tree : t -> Tree.t
                          val to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:id ->
                            ?less_or_equal_to:id -> t -> id Base__.Sequence.t
                          val merge_to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:id ->
                            ?less_or_equal_to:id ->
                            t ->
                            t ->
                            (id, id)
                            Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                            Base__.Sequence.t
                          val to_map :
                            t ->
                            f:(id -> 'data) ->
                            (id, 'data, comparator_witness)
                            Core_kernel__.Core_set_intf.Map.t
                          val obs :
                            id Core_kernel__.Quickcheck.Observer.t ->
                            t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            id Core_kernel__.Quickcheck.Shrinker.t ->
                            t Core_kernel__.Quickcheck.Shrinker.t
                          val empty : t
                          val singleton : id -> t
                          val union_list : t List.t -> t
                          val of_list : id List.t -> t
                          val of_array : id array -> t
                          val of_sorted_array :
                            id array -> t Base__.Or_error.t
                          val of_sorted_array_unchecked : id array -> t
                          val of_increasing_iterator_unchecked :
                            len:Monoid.Int.t -> f:(Monoid.Int.t -> id) -> t
                          val stable_dedup_list : id List.t -> id List.t
                          val map : ('a, 'b) Base.Set.t -> f:('-> id) -> t
                          val filter_map :
                            ('a, 'b) Base.Set.t -> f:('-> id Option.t) -> t
                          val of_tree : Tree.t -> t
                          val of_hash_set : id Core_kernel__.Hash_set.t -> t
                          val of_hashtbl_keys :
                            (id, 'a) Core_kernel__.Core_hashtbl.t -> t
                          val of_map_keys :
                            (id, 'a, comparator_witness)
                            Core_kernel__.Core_set_intf.Map.t -> t
                          val gen :
                            id Core_kernel__.Quickcheck.Generator.t ->
                            t Core_kernel__.Quickcheck.Generator.t
                          module Provide_of_sexp :
                            functor
                              (Elt : sig
                                       val t_of_sexp : Sexplib.Sexp.t -> id
                                     end->
                              sig val t_of_sexp : Sexplib.Sexp.t -> t end
                          module Provide_bin_io :
                            functor
                              (Elt : sig
                                       val bin_t : id Bin_prot.Type_class.t
                                       val bin_read_t :
                                         id Bin_prot.Read.reader
                                       val __bin_read_t__ :
                                         (Core_kernel__.Import.int -> id)
                                         Bin_prot.Read.reader
                                       val bin_reader_t :
                                         id Bin_prot.Type_class.reader
                                       val bin_size_t :
                                         id Bin_prot.Size.sizer
                                       val bin_write_t :
                                         id Bin_prot.Write.writer
                                       val bin_writer_t :
                                         id Bin_prot.Type_class.writer
                                       val bin_shape_t : Bin_prot.Shape.t
                                     end->
                              sig
                                val bin_size_t : t Bin_prot.Size.sizer
                                val bin_write_t : t Bin_prot.Write.writer
                                val bin_read_t : t Bin_prot.Read.reader
                                val __bin_read_t__ :
                                  (Monoid.Int.t -> t) Bin_prot.Read.reader
                                val bin_shape_t : Bin_prot.Shape.t
                                val bin_writer_t :
                                  t Bin_prot.Type_class.writer
                                val bin_reader_t :
                                  t Bin_prot.Type_class.reader
                                val bin_t : t Bin_prot.Type_class.t
                              end
                          module Provide_hash :
                            functor
                              (Elt : sig
                                       val hash_fold_t :
                                         Base__.Hash.state ->
                                         id -> Base__.Hash.state
                                     end->
                              sig
                                val hash_fold_t :
                                  Ppx_hash_lib.Std.Hash.state ->
                                  t -> Ppx_hash_lib.Std.Hash.state
                                val hash :
                                  t -> Ppx_hash_lib.Std.Hash.hash_value
                              end
                          val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (Monoid.Int.t -> t) Bin_prot.Read.reader
                          val bin_shape_t : Bin_prot.Shape.t
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_t : t Bin_prot.Type_class.t
                        end
                      val hash : t -> Core_kernel__.Import.int
                      val hashable :
                        t Core_kernel__.Hashable.Hashtbl.Hashable.t
                      module Table :
                        sig
                          type key = t
                          type ('a, 'b) hashtbl =
                              ('a, 'b) Core_kernel__.Hashable.Hashtbl.t
                          type 'b t = (key, 'b) hashtbl
                          val sexp_of_t :
                            ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                          type ('a, 'b) t_ = 'b t
                          type 'a key_ = key
                          val hashable :
                            key Core_kernel__.Core_hashtbl_intf.Hashable.t
                          val invariant :
                            'Base__.Invariant_intf.inv ->
                            'a t Base__.Invariant_intf.inv
                          val create :
                            (key, 'b, Monoid.Unit.t -> 'b t)
                            Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                          val of_alist :
                            (key, 'b,
                             (key * 'b) List.t ->
                             [ `Duplicate_key of key | `Ok of 'b t ])
                            Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                          val of_alist_report_all_dups :
                            (key, 'b,
                             (key * 'b) List.t ->
                             [ `Duplicate_keys of key List.t | `Ok of 'b t ])
                            Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                          val of_alist_or_error :
                            (key, 'b,
                             (key * 'b) List.t -> 'b t Base__.Or_error.t)
                            Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                          val of_alist_exn :
                            (key, 'b, (key * 'b) List.t -> 'b t)
                            Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                          val of_alist_multi :
                            (key, 'List.t,
                             (key * 'b) List.t -> 'List.t t)
                            Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                          val create_mapped :
                            (key, 'b,
                             get_key:('-> key) ->
                             get_data:('-> 'b) ->
                             'List.t ->
                             [ `Duplicate_keys of key List.t | `Ok of 'b t ])
                            Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                          val create_with_key :
                            (key, 'r,
                             get_key:('-> key) ->
                             'List.t ->
                             [ `Duplicate_keys of key List.t | `Ok of 'r t ])
                            Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                          val create_with_key_or_error :
                            (key, 'r,
                             get_key:('-> key) ->
                             'List.t -> 'r t Base__.Or_error.t)
                            Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                          val create_with_key_exn :
                            (key, 'r,
                             get_key:('-> key) -> 'List.t -> 'r t)
                            Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                          val group :
                            (key, 'b,
                             get_key:('-> key) ->
                             get_data:('-> 'b) ->
                             combine:('-> '-> 'b) -> 'List.t -> 'b t)
                            Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                          val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                          val clear : 'a t -> Monoid.Unit.t
                          val copy : 'b t -> 'b t
                          val fold :
                            'b t ->
                            init:'->
                            f:(key:key -> data:'-> '-> 'c) -> 'c
                          val iter_keys :
                            'a t -> f:(key -> Monoid.Unit.t) -> Monoid.Unit.t
                          val iter :
                            'b t -> f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                          val iteri :
                            'b t ->
                            f:(key:key -> data:'-> Monoid.Unit.t) ->
                            Monoid.Unit.t
                          val iter_vals :
                            'b t -> f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                          val existsi :
                            'b t -> f:(key:key -> data:'-> bool) -> bool
                          val exists : 'b t -> f:('-> bool) -> bool
                          val for_alli :
                            'b t -> f:(key:key -> data:'-> bool) -> bool
                          val for_all : 'b t -> f:('-> bool) -> bool
                          val counti :
                            'b t ->
                            f:(key:key -> data:'-> bool) -> Monoid.Int.t
                          val count : 'b t -> f:('-> bool) -> Monoid.Int.t
                          val length : 'a t -> Monoid.Int.t
                          val is_empty : 'a t -> bool
                          val mem : 'a t -> key -> bool
                          val remove : 'a t -> key -> Monoid.Unit.t
                          val replace :
                            'b t -> key:key -> data:'-> Monoid.Unit.t
                          val set :
                            'b t -> key:key -> data:'-> Monoid.Unit.t
                          val add :
                            'b t ->
                            key:key -> data:'-> [ `Duplicate | `Ok ]
                          val add_or_error :
                            'b t ->
                            key:key ->
                            data:'-> Monoid.Unit.t Base__.Or_error.t
                          val add_exn :
                            'b t -> key:key -> data:'-> Monoid.Unit.t
                          val change :
                            'b t ->
                            key ->
                            f:('Option.t -> 'Option.t) -> Monoid.Unit.t
                          val update :
                            'b t ->
                            key -> f:('Option.t -> 'b) -> Monoid.Unit.t
                          val add_multi :
                            'List.t t ->
                            key:key -> data:'-> Monoid.Unit.t
                          val remove_multi :
                            'List.t t -> key -> Monoid.Unit.t
                          val map : 'b t -> f:('-> 'c) -> 'c t
                          val mapi :
                            'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                          val filter_map :
                            'b t -> f:('-> 'Option.t) -> 'c t
                          val filter_mapi :
                            'b t ->
                            f:(key:key -> data:'-> 'Option.t) -> 'c t
                          val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                          val filter : 'b t -> f:('-> bool) -> 'b t
                          val filteri :
                            'b t -> f:(key:key -> data:'-> bool) -> 'b t
                          val partition_map :
                            'b t ->
                            f:('-> [ `Fst of '| `Snd of 'd ]) ->
                            'c t * 'd t
                          val partition_mapi :
                            'b t ->
                            f:(key:key ->
                               data:'-> [ `Fst of '| `Snd of 'd ]) ->
                            'c t * 'd t
                          val partition_tf :
                            'b t -> f:('-> bool) -> 'b t * 'b t
                          val partitioni_tf :
                            'b t ->
                            f:(key:key -> data:'-> bool) -> 'b t * 'b t
                          val find_or_add :
                            'b t ->
                            key -> default:(Monoid.Unit.t -> 'b) -> 'b
                          val find : 'b t -> key -> 'Option.t
                          val find_exn : 'b t -> key -> 'b
                          val find_and_call :
                            'b t ->
                            key ->
                            if_found:('-> 'c) ->
                            if_not_found:(key -> 'c) -> 'c
                          val find_and_remove : 'b t -> key -> 'Option.t
                          val merge :
                            'a t ->
                            'b t ->
                            f:(key:key ->
                               [ `Both of 'a * 'b
                               | `Left of 'a
                               | `Right of 'b ] -> 'Option.t) ->
                            'c t
                          type 'a merge_into_action = Remove | Set_to of 'a
                          val merge_into :
                            src:'a t ->
                            dst:'b t ->
                            f:(key:key ->
                               '-> 'Option.t -> 'b merge_into_action) ->
                            Monoid.Unit.t
                          val keys : 'a t -> key List.t
                          val data : 'b t -> 'List.t
                          val filter_keys_inplace :
                            'a t -> f:(key -> bool) -> Monoid.Unit.t
                          val filter_inplace :
                            'b t -> f:('-> bool) -> Monoid.Unit.t
                          val filteri_inplace :
                            'b t ->
                            f:(key:key -> data:'-> bool) -> Monoid.Unit.t
                          val map_inplace :
                            'b t -> f:('-> 'b) -> Monoid.Unit.t
                          val mapi_inplace :
                            'b t ->
                            f:(key:key -> data:'-> 'b) -> Monoid.Unit.t
                          val filter_map_inplace :
                            'b t -> f:('-> 'Option.t) -> Monoid.Unit.t
                          val filter_mapi_inplace :
                            'b t ->
                            f:(key:key -> data:'-> 'Option.t) ->
                            Monoid.Unit.t
                          val replace_all :
                            'b t -> f:('-> 'b) -> Monoid.Unit.t
                          val replace_alli :
                            'b t ->
                            f:(key:key -> data:'-> 'b) -> Monoid.Unit.t
                          val filter_replace_all :
                            'b t -> f:('-> 'Option.t) -> Monoid.Unit.t
                          val filter_replace_alli :
                            'b t ->
                            f:(key:key -> data:'-> 'Option.t) ->
                            Monoid.Unit.t
                          val equal :
                            'b t -> 'b t -> ('-> '-> bool) -> bool
                          val similar :
                            'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                          val to_alist : 'b t -> (key * 'b) List.t
                          val validate :
                            name:(key -> Monoid.String.t) ->
                            'Base__.Validate.check ->
                            'b t Base__.Validate.check
                          val incr :
                            ?by:Monoid.Int.t ->
                            ?remove_if_zero:bool ->
                            Monoid.Int.t t -> key -> Monoid.Unit.t
                          val decr :
                            ?by:Monoid.Int.t ->
                            ?remove_if_zero:bool ->
                            Monoid.Int.t t -> key -> Monoid.Unit.t
                          module Provide_of_sexp :
                            functor
                              (Key : sig
                                       val t_of_sexp : Sexplib.Sexp.t -> key
                                     end->
                              sig
                                val t_of_sexp :
                                  (Sexplib.Sexp.t -> 'v_x__001_) ->
                                  Sexplib.Sexp.t -> 'v_x__001_ t
                              end
                          module Provide_bin_io :
                            functor
                              (Key : sig
                                       val bin_t : key Bin_prot.Type_class.t
                                       val bin_read_t :
                                         key Bin_prot.Read.reader
                                       val __bin_read_t__ :
                                         (Core_kernel__.Import.int -> key)
                                         Bin_prot.Read.reader
                                       val bin_reader_t :
                                         key Bin_prot.Type_class.reader
                                       val bin_size_t :
                                         key Bin_prot.Size.sizer
                                       val bin_write_t :
                                         key Bin_prot.Write.writer
                                       val bin_writer_t :
                                         key Bin_prot.Type_class.writer
                                       val bin_shape_t : Bin_prot.Shape.t
                                     end->
                              sig
                                val bin_t :
                                  'Bin_prot.Type_class.t ->
                                  'a t Bin_prot.Type_class.t
                                val bin_read_t :
                                  'Bin_prot.Read.reader ->
                                  'a t Bin_prot.Read.reader
                                val __bin_read_t__ :
                                  'Bin_prot.Read.reader ->
                                  (Core_kernel__.Import.int -> 'a t)
                                  Bin_prot.Read.reader
                                val bin_reader_t :
                                  'Bin_prot.Type_class.reader ->
                                  'a t Bin_prot.Type_class.reader
                                val bin_size_t :
                                  'Bin_prot.Size.sizer ->
                                  'a t Bin_prot.Size.sizer
                                val bin_write_t :
                                  'Bin_prot.Write.writer ->
                                  'a t Bin_prot.Write.writer
                                val bin_writer_t :
                                  'Bin_prot.Type_class.writer ->
                                  'a t Bin_prot.Type_class.writer
                                val bin_shape_t :
                                  Bin_prot.Shape.t -> Bin_prot.Shape.t
                              end
                          val t_of_sexp :
                            (Sexplib.Sexp.t -> 'v_x__002_) ->
                            Sexplib.Sexp.t -> 'v_x__002_ t
                          val bin_shape_t :
                            Bin_prot.Shape.t -> Bin_prot.Shape.t
                          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                          val __bin_read_t__ :
                            ('a, Monoid.Int.t -> 'a t) Bin_prot.Read.reader1
                          val bin_writer_t :
                            ('a, 'a t) Bin_prot.Type_class.S1.writer
                          val bin_reader_t :
                            ('a, 'a t) Bin_prot.Type_class.S1.reader
                          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                        end
                      module Hash_set :
                        sig
                          type elt = t
                          type t = elt Core_kernel__.Hash_set.t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          type 'a t_ = t
                          type 'a elt_ = elt
                          val create :
                            ('a, Monoid.Unit.t -> t)
                            Core_kernel__.Hash_set_intf.create_options_without_hashable
                          val of_list :
                            ('a, elt List.t -> t)
                            Core_kernel__.Hash_set_intf.create_options_without_hashable
                          module Provide_of_sexp :
                            functor
                              (X : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> elt
                                   end->
                              sig val t_of_sexp : Sexplib.Sexp.t -> t end
                          module Provide_bin_io :
                            functor
                              (X : sig
                                     val bin_t : elt Bin_prot.Type_class.t
                                     val bin_read_t :
                                       elt Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> elt)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       elt Bin_prot.Type_class.reader
                                     val bin_size_t : elt Bin_prot.Size.sizer
                                     val bin_write_t :
                                       elt Bin_prot.Write.writer
                                     val bin_writer_t :
                                       elt Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                              sig
                                val bin_t : t Bin_prot.Type_class.t
                                val bin_read_t : t Bin_prot.Read.reader
                                val __bin_read_t__ :
                                  (Core_kernel__.Import.int -> t)
                                  Bin_prot.Read.reader
                                val bin_reader_t :
                                  t Bin_prot.Type_class.reader
                                val bin_size_t : t Bin_prot.Size.sizer
                                val bin_write_t : t Bin_prot.Write.writer
                                val bin_writer_t :
                                  t Bin_prot.Type_class.writer
                                val bin_shape_t : Bin_prot.Shape.t
                              end
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (Monoid.Int.t -> t) Bin_prot.Read.reader
                          val bin_shape_t : Bin_prot.Shape.t
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_t : t Bin_prot.Type_class.t
                        end
                      module Hash_queue :
                        sig
                          module Key :
                            sig
                              type t = id
                              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                              val compare : t -> t -> Monoid.Int.t
                              val hash : t -> Monoid.Int.t
                            end
                          type 'a t
                          val sexp_of_t :
                            ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                          val length : 'a t -> Monoid.Int.t
                          val is_empty : 'a t -> bool
                          val iter :
                            'a t -> f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                          val fold :
                            'a t ->
                            init:'accum ->
                            f:('accum -> '-> 'accum) -> 'accum
                          val fold_result :
                            'a t ->
                            init:'accum ->
                            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                            ('accum, 'e) Base__.Result.t
                          val fold_until :
                            'a t ->
                            init:'accum ->
                            f:('accum ->
                               '->
                               ('accum, 'stop)
                               Base.Container_intf.Continue_or_stop.t) ->
                            ('accum, 'stop)
                            Base.Container_intf.Finished_or_stopped_early.t
                          val exists : 'a t -> f:('-> bool) -> bool
                          val for_all : 'a t -> f:('-> bool) -> bool
                          val count : 'a t -> f:('-> bool) -> Monoid.Int.t
                          val sum :
                            (module Base__.Commutative_group.S with type t = 'sum) ->
                            'a t -> f:('-> 'sum) -> 'sum
                          val find : 'a t -> f:('-> bool) -> 'Option.t
                          val find_map :
                            'a t -> f:('-> 'Option.t) -> 'Option.t
                          val to_list : 'a t -> 'List.t
                          val to_array : 'a t -> 'a array
                          val min_elt :
                            'a t ->
                            cmp:('-> '-> Monoid.Int.t) -> 'Option.t
                          val max_elt :
                            'a t ->
                            cmp:('-> '-> Monoid.Int.t) -> 'Option.t
                          val invariant : 'a t -> Core_kernel__.Import.unit
                          val create :
                            ?growth_allowed:Core_kernel__.Import.bool ->
                            ?size:Core_kernel__.Import.int ->
                            Core_kernel__.Import.unit -> 'a t
                          val clear : 'a t -> Core_kernel__.Import.unit
                          val mem : 'a t -> id -> Core_kernel__.Import.bool
                          val lookup :
                            'a t -> id -> 'Core_kernel__.Import.option
                          val lookup_exn : 'a t -> id -> 'a
                          val enqueue :
                            'a t ->
                            id -> '-> [ `Key_already_present | `Ok ]
                          val enqueue_exn :
                            'a t -> id -> '-> Core_kernel__.Import.unit
                          val lookup_and_move_to_back :
                            'a t -> id -> 'Core_kernel__.Import.option
                          val lookup_and_move_to_back_exn : 'a t -> id -> 'a
                          val first : 'a t -> 'Core_kernel__.Import.option
                          val first_with_key :
                            'a t -> (id * 'a) Core_kernel__.Import.option
                          val keys : 'a t -> id Core_kernel__.Import.list
                          val dequeue :
                            'a t -> 'Core_kernel__.Import.option
                          val dequeue_exn : 'a t -> 'a
                          val dequeue_with_key :
                            'a t -> (id * 'a) Core_kernel__.Import.option
                          val dequeue_with_key_exn : 'a t -> id * 'a
                          val dequeue_all :
                            'a t ->
                            f:('-> Core_kernel__.Import.unit) ->
                            Core_kernel__.Import.unit
                          val remove : 'a t -> id -> [ `No_such_key | `Ok ]
                          val remove_exn :
                            'a t -> id -> Core_kernel__.Import.unit
                          val replace :
                            'a t -> id -> '-> [ `No_such_key | `Ok ]
                          val replace_exn :
                            'a t -> id -> '-> Core_kernel__.Import.unit
                          val iteri :
                            'a t ->
                            f:(key:id -> data:'-> Core_kernel__.Import.unit) ->
                            Core_kernel__.Import.unit
                          val foldi :
                            'a t ->
                            init:'->
                            f:('-> key:id -> data:'-> 'b) -> 'b
                        end
                      val pp :
                        Format.formatter ->
                        Monads.Std.Monad.State.Multi.id -> unit
                    end
                  module type S =
                    sig
                      type 'a t
                      type 'a m
                      type 'a e
                      type id
                      module Id :
                        sig
                          type t = id
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          val bin_t : t Bin_prot.Type_class.t
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (Core_kernel__.Import.int -> t)
                            Bin_prot.Read.reader
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_shape_t : Bin_prot.Shape.t
                          val of_string : Monoid.String.t -> t
                          val to_string : t -> Monoid.String.t
                          val ( >= ) : t -> t -> bool
                          val ( <= ) : t -> t -> bool
                          val ( = ) : t -> t -> bool
                          val ( > ) : t -> t -> bool
                          val ( < ) : t -> t -> bool
                          val ( <> ) : t -> t -> bool
                          val equal : t -> t -> bool
                          val compare : t -> t -> Monoid.Int.t
                          val min : t -> t -> t
                          val max : t -> t -> t
                          val ascending : t -> t -> Monoid.Int.t
                          val descending : t -> t -> Monoid.Int.t
                          val between : t -> low:t -> high:t -> bool
                          val clamp_exn : t -> min:t -> max:t -> t
                          val clamp :
                            t -> min:t -> max:t -> t Base__.Or_error.t
                          type comparator_witness
                          val validate_lbound :
                            min:t Base__.Maybe_bound.t ->
                            t Base__.Validate.check
                          val validate_ubound :
                            max:t Base__.Maybe_bound.t ->
                            t Base__.Validate.check
                          val validate_bound :
                            min:t Base__.Maybe_bound.t ->
                            max:t Base__.Maybe_bound.t ->
                            t Base__.Validate.check
                          module Replace_polymorphic_compare :
                            sig
                              val ( >= ) : t -> t -> bool
                              val ( <= ) : t -> t -> bool
                              val ( = ) : t -> t -> bool
                              val ( > ) : t -> t -> bool
                              val ( < ) : t -> t -> bool
                              val ( <> ) : t -> t -> bool
                              val equal : t -> t -> bool
                              val compare : t -> t -> Monoid.Int.t
                              val min : t -> t -> t
                              val max : t -> t -> t
                            end
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                          module Map :
                            sig
                              module Key :
                                sig
                                  type t = id
                                  val t_of_sexp : Sexplib.Sexp.t -> t
                                  val sexp_of_t : t -> Sexplib.Sexp.t
                                  val bin_t : t Bin_prot.Type_class.t
                                  val bin_read_t : t Bin_prot.Read.reader
                                  val __bin_read_t__ :
                                    (Core_kernel__.Import.int -> t)
                                    Bin_prot.Read.reader
                                  val bin_reader_t :
                                    t Bin_prot.Type_class.reader
                                  val bin_size_t : t Bin_prot.Size.sizer
                                  val bin_write_t : t Bin_prot.Write.writer
                                  val bin_writer_t :
                                    t Bin_prot.Type_class.writer
                                  val bin_shape_t : Bin_prot.Shape.t
                                  type comparator_witness =
                                      comparator_witness
                                  val comparator :
                                    (t, comparator_witness)
                                    Core_kernel__.Comparator.comparator
                                end
                              module Tree :
                                sig
                                  type 'a t =
                                      (id, 'a, comparator_witness)
                                      Core_kernel__.Core_map_intf.Tree.t
                                  val empty : 'a t
                                  val singleton : id -> '-> 'a t
                                  val of_alist :
                                    (id * 'a) List.t ->
                                    [ `Duplicate_key of id | `Ok of 'a t ]
                                  val of_alist_or_error :
                                    (id * 'a) List.t ->
                                    'a t Base__.Or_error.t
                                  val of_alist_exn : (id * 'a) List.t -> 'a t
                                  val of_alist_multi :
                                    (id * 'a) List.t -> 'List.t t
                                  val of_alist_fold :
                                    (id * 'a) List.t ->
                                    init:'-> f:('-> '-> 'b) -> 'b t
                                  val of_alist_reduce :
                                    (id * 'a) List.t ->
                                    f:('-> '-> 'a) -> 'a t
                                  val of_sorted_array :
                                    (id * 'a) array -> 'a t Base__.Or_error.t
                                  val of_sorted_array_unchecked :
                                    (id * 'a) array -> 'a t
                                  val of_increasing_iterator_unchecked :
                                    len:Monoid.Int.t ->
                                    f:(Monoid.Int.t -> id * 'a) -> 'a t
                                  val of_iteri :
                                    iteri:(f:(key:id ->
                                              data:'-> Monoid.Unit.t) ->
                                           Monoid.Unit.t) ->
                                    [ `Duplicate_key of id | `Ok of 'v t ]
                                  val of_tree : 'a t -> 'a t
                                  val of_hashtbl_exn :
                                    (id, 'a) Core_kernel__.Core_hashtbl.t ->
                                    'a t
                                  val gen :
                                    id Core_kernel__.Quickcheck.Generator.t ->
                                    'Core_kernel__.Quickcheck.Generator.t ->
                                    'a t Core_kernel__.Quickcheck.Generator.t
                                  val invariants : 'a t -> bool
                                  val is_empty : 'a t -> bool
                                  val length : 'a t -> Monoid.Int.t
                                  val add : 'a t -> key:id -> data:'-> 'a t
                                  val add_multi :
                                    'List.t t ->
                                    key:id -> data:'-> 'List.t t
                                  val remove_multi :
                                    'List.t t -> id -> 'List.t t
                                  val change :
                                    'a t ->
                                    id ->
                                    f:('Option.t -> 'Option.t) -> 'a t
                                  val update :
                                    'a t ->
                                    id -> f:('Option.t -> 'a) -> 'a t
                                  val find : 'a t -> id -> 'Option.t
                                  val find_exn : 'a t -> id -> 'a
                                  val remove : 'a t -> id -> 'a t
                                  val mem : 'a t -> id -> bool
                                  val iter_keys :
                                    'a t ->
                                    f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
                                  val iter :
                                    'a t ->
                                    f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                                  val iteri :
                                    'a t ->
                                    f:(key:id -> data:'-> Monoid.Unit.t) ->
                                    Monoid.Unit.t
                                  val iter2 :
                                    'a t ->
                                    'b t ->
                                    f:(key:id ->
                                       data:[ `Both of 'a * 'b
                                            | `Left of 'a
                                            | `Right of 'b ] ->
                                       Monoid.Unit.t) ->
                                    Monoid.Unit.t
                                  val map : 'a t -> f:('-> 'b) -> 'b t
                                  val mapi :
                                    'a t ->
                                    f:(key:id -> data:'-> 'b) -> 'b t
                                  val fold :
                                    'a t ->
                                    init:'->
                                    f:(key:id -> data:'-> '-> 'b) -> 'b
                                  val fold_right :
                                    'a t ->
                                    init:'->
                                    f:(key:id -> data:'-> '-> 'b) -> 'b
                                  val fold2 :
                                    'a t ->
                                    'b t ->
                                    init:'->
                                    f:(key:id ->
                                       data:[ `Both of 'a * 'b
                                            | `Left of 'a
                                            | `Right of 'b ] ->
                                       '-> 'c) ->
                                    'c
                                  val filter_keys :
                                    'a t -> f:(id -> bool) -> 'a t
                                  val filter : 'a t -> f:('-> bool) -> 'a t
                                  val filteri :
                                    'a t ->
                                    f:(key:id -> data:'-> bool) -> 'a t
                                  val filter_map :
                                    'a t -> f:('-> 'Option.t) -> 'b t
                                  val filter_mapi :
                                    'a t ->
                                    f:(key:id -> data:'-> 'Option.t) ->
                                    'b t
                                  val partition_mapi :
                                    'a t ->
                                    f:(key:id ->
                                       data:'-> [ `Fst of '| `Snd of 'c ]) ->
                                    'b t * 'c t
                                  val partition_map :
                                    'a t ->
                                    f:('-> [ `Fst of '| `Snd of 'c ]) ->
                                    'b t * 'c t
                                  val partitioni_tf :
                                    'a t ->
                                    f:(key:id -> data:'-> bool) ->
                                    'a t * 'a t
                                  val partition_tf :
                                    'a t -> f:('-> bool) -> 'a t * 'a t
                                  val compare_direct :
                                    ('-> '-> Monoid.Int.t) ->
                                    'a t -> 'a t -> Monoid.Int.t
                                  val equal :
                                    ('-> '-> bool) ->
                                    'a t -> 'a t -> bool
                                  val keys : 'a t -> id List.t
                                  val data : 'a t -> 'List.t
                                  val to_alist :
                                    ?key_order:[ `Decreasing | `Increasing ] ->
                                    'a t -> (id * 'a) List.t
                                  val validate :
                                    name:(id -> Monoid.String.t) ->
                                    'Base__.Validate.check ->
                                    'a t Base__.Validate.check
                                  val merge :
                                    'a t ->
                                    'b t ->
                                    f:(key:id ->
                                       [ `Both of 'a * 'b
                                       | `Left of 'a
                                       | `Right of 'b ] -> 'Option.t) ->
                                    'c t
                                  val symmetric_diff :
                                    'a t ->
                                    'a t ->
                                    data_equal:('-> '-> bool) ->
                                    (id, 'a)
                                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                                    Base__.Sequence.t
                                  val min_elt : 'a t -> (id * 'a) Option.t
                                  val min_elt_exn : 'a t -> id * 'a
                                  val max_elt : 'a t -> (id * 'a) Option.t
                                  val max_elt_exn : 'a t -> id * 'a
                                  val for_all :
                                    'a t -> f:('-> bool) -> bool
                                  val for_alli :
                                    'a t ->
                                    f:(key:id -> data:'-> bool) -> bool
                                  val exists : 'a t -> f:('-> bool) -> bool
                                  val existsi :
                                    'a t ->
                                    f:(key:id -> data:'-> bool) -> bool
                                  val count :
                                    'a t -> f:('-> bool) -> Monoid.Int.t
                                  val counti :
                                    'a t ->
                                    f:(key:id -> data:'-> bool) ->
                                    Monoid.Int.t
                                  val split :
                                    'a t ->
                                    id -> 'a t * (id * 'a) Option.t * 'a t
                                  val append :
                                    lower_part:'a t ->
                                    upper_part:'a t ->
                                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                                  val subrange :
                                    'a t ->
                                    lower_bound:id Base__.Maybe_bound.t ->
                                    upper_bound:id Base__.Maybe_bound.t ->
                                    'a t
                                  val fold_range_inclusive :
                                    'a t ->
                                    min:id ->
                                    max:id ->
                                    init:'->
                                    f:(key:id -> data:'-> '-> 'b) -> 'b
                                  val range_to_alist :
                                    'a t ->
                                    min:id -> max:id -> (id * 'a) List.t
                                  val closest_key :
                                    'a t ->
                                    [ `Greater_or_equal_to
                                    | `Greater_than
                                    | `Less_or_equal_to
                                    | `Less_than ] ->
                                    id -> (id * 'a) Option.t
                                  val nth :
                                    'a t ->
                                    Monoid.Int.t -> (id * 'a) Option.t
                                  val nth_exn :
                                    'a t -> Monoid.Int.t -> id * 'a
                                  val rank :
                                    'a t -> id -> Monoid.Int.t Option.t
                                  val to_tree : 'a t -> 'a t
                                  val to_sequence :
                                    ?order:[ `Decreasing_key
                                           | `Increasing_key ] ->
                                    ?keys_greater_or_equal_to:id ->
                                    ?keys_less_or_equal_to:id ->
                                    'a t -> (id * 'a) Base__.Sequence.t
                                  val obs :
                                    id Core_kernel__.Quickcheck.Observer.t ->
                                    'Core_kernel__.Quickcheck.Observer.t ->
                                    'v t Core_kernel__.Quickcheck.Observer.t
                                  val shrinker :
                                    id Core_kernel__.Quickcheck.Shrinker.t ->
                                    'Core_kernel__.Quickcheck.Shrinker.t ->
                                    'v t Core_kernel__.Quickcheck.Shrinker.t
                                  module Provide_of_sexp :
                                    functor
                                      (K : sig
                                             val t_of_sexp :
                                               Sexplib.Sexp.t -> id
                                           end->
                                      sig
                                        val t_of_sexp :
                                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                                          Sexplib.Sexp.t -> 'v_x__017_ t
                                      end
                                  val t_of_sexp :
                                    (Base__.Sexplib.Sexp.t -> 'a) ->
                                    Base__.Sexplib.Sexp.t -> 'a t
                                  val sexp_of_t :
                                    ('-> Base__.Sexplib.Sexp.t) ->
                                    'a t -> Base__.Sexplib.Sexp.t
                                end
                              type 'a t =
                                  (id, 'a, comparator_witness)
                                  Core_kernel__.Core_map_intf.Map.t
                              val compare :
                                ('-> '-> Core_kernel__.Import.int) ->
                                'a t -> 'a t -> Core_kernel__.Import.int
                              val empty : 'a t
                              val singleton : id -> '-> 'a t
                              val of_alist :
                                (id * 'a) List.t ->
                                [ `Duplicate_key of id | `Ok of 'a t ]
                              val of_alist_or_error :
                                (id * 'a) List.t -> 'a t Base__.Or_error.t
                              val of_alist_exn : (id * 'a) List.t -> 'a t
                              val of_alist_multi :
                                (id * 'a) List.t -> 'List.t t
                              val of_alist_fold :
                                (id * 'a) List.t ->
                                init:'-> f:('-> '-> 'b) -> 'b t
                              val of_alist_reduce :
                                (id * 'a) List.t ->
                                f:('-> '-> 'a) -> 'a t
                              val of_sorted_array :
                                (id * 'a) array -> 'a t Base__.Or_error.t
                              val of_sorted_array_unchecked :
                                (id * 'a) array -> 'a t
                              val of_increasing_iterator_unchecked :
                                len:Monoid.Int.t ->
                                f:(Monoid.Int.t -> id * 'a) -> 'a t
                              val of_iteri :
                                iteri:(f:(key:id -> data:'-> Monoid.Unit.t) ->
                                       Monoid.Unit.t) ->
                                [ `Duplicate_key of id | `Ok of 'v t ]
                              val of_tree : 'Tree.t -> 'a t
                              val of_hashtbl_exn :
                                (id, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                              val gen :
                                id Core_kernel__.Quickcheck.Generator.t ->
                                'Core_kernel__.Quickcheck.Generator.t ->
                                'a t Core_kernel__.Quickcheck.Generator.t
                              val invariants : 'a t -> bool
                              val is_empty : 'a t -> bool
                              val length : 'a t -> Monoid.Int.t
                              val add : 'a t -> key:id -> data:'-> 'a t
                              val add_multi :
                                'List.t t ->
                                key:id -> data:'-> 'List.t t
                              val remove_multi :
                                'List.t t -> id -> 'List.t t
                              val change :
                                'a t ->
                                id -> f:('Option.t -> 'Option.t) -> 'a t
                              val update :
                                'a t -> id -> f:('Option.t -> 'a) -> 'a t
                              val find : 'a t -> id -> 'Option.t
                              val find_exn : 'a t -> id -> 'a
                              val remove : 'a t -> id -> 'a t
                              val mem : 'a t -> id -> bool
                              val iter_keys :
                                'a t ->
                                f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
                              val iter :
                                'a t ->
                                f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                              val iteri :
                                'a t ->
                                f:(key:id -> data:'-> Monoid.Unit.t) ->
                                Monoid.Unit.t
                              val iter2 :
                                'a t ->
                                'b t ->
                                f:(key:id ->
                                   data:[ `Both of 'a * 'b
                                        | `Left of 'a
                                        | `Right of 'b ] ->
                                   Monoid.Unit.t) ->
                                Monoid.Unit.t
                              val map : 'a t -> f:('-> 'b) -> 'b t
                              val mapi :
                                'a t -> f:(key:id -> data:'-> 'b) -> 'b t
                              val fold :
                                'a t ->
                                init:'->
                                f:(key:id -> data:'-> '-> 'b) -> 'b
                              val fold_right :
                                'a t ->
                                init:'->
                                f:(key:id -> data:'-> '-> 'b) -> 'b
                              val fold2 :
                                'a t ->
                                'b t ->
                                init:'->
                                f:(key:id ->
                                   data:[ `Both of 'a * 'b
                                        | `Left of 'a
                                        | `Right of 'b ] ->
                                   '-> 'c) ->
                                'c
                              val filter_keys :
                                'a t -> f:(id -> bool) -> 'a t
                              val filter : 'a t -> f:('-> bool) -> 'a t
                              val filteri :
                                'a t -> f:(key:id -> data:'-> bool) -> 'a t
                              val filter_map :
                                'a t -> f:('-> 'Option.t) -> 'b t
                              val filter_mapi :
                                'a t ->
                                f:(key:id -> data:'-> 'Option.t) -> 'b t
                              val partition_mapi :
                                'a t ->
                                f:(key:id ->
                                   data:'-> [ `Fst of '| `Snd of 'c ]) ->
                                'b t * 'c t
                              val partition_map :
                                'a t ->
                                f:('-> [ `Fst of '| `Snd of 'c ]) ->
                                'b t * 'c t
                              val partitioni_tf :
                                'a t ->
                                f:(key:id -> data:'-> bool) -> 'a t * 'a t
                              val partition_tf :
                                'a t -> f:('-> bool) -> 'a t * 'a t
                              val compare_direct :
                                ('-> '-> Monoid.Int.t) ->
                                'a t -> 'a t -> Monoid.Int.t
                              val equal :
                                ('-> '-> bool) -> 'a t -> 'a t -> bool
                              val keys : 'a t -> id List.t
                              val data : 'a t -> 'List.t
                              val to_alist :
                                ?key_order:[ `Decreasing | `Increasing ] ->
                                'a t -> (id * 'a) List.t
                              val validate :
                                name:(id -> Monoid.String.t) ->
                                'Base__.Validate.check ->
                                'a t Base__.Validate.check
                              val merge :
                                'a t ->
                                'b t ->
                                f:(key:id ->
                                   [ `Both of 'a * 'b
                                   | `Left of 'a
                                   | `Right of 'b ] -> 'Option.t) ->
                                'c t
                              val symmetric_diff :
                                'a t ->
                                'a t ->
                                data_equal:('-> '-> bool) ->
                                (id, 'a)
                                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                                Base__.Sequence.t
                              val min_elt : 'a t -> (id * 'a) Option.t
                              val min_elt_exn : 'a t -> id * 'a
                              val max_elt : 'a t -> (id * 'a) Option.t
                              val max_elt_exn : 'a t -> id * 'a
                              val for_all : 'a t -> f:('-> bool) -> bool
                              val for_alli :
                                'a t -> f:(key:id -> data:'-> bool) -> bool
                              val exists : 'a t -> f:('-> bool) -> bool
                              val existsi :
                                'a t -> f:(key:id -> data:'-> bool) -> bool
                              val count :
                                'a t -> f:('-> bool) -> Monoid.Int.t
                              val counti :
                                'a t ->
                                f:(key:id -> data:'-> bool) -> Monoid.Int.t
                              val split :
                                'a t ->
                                id -> 'a t * (id * 'a) Option.t * 'a t
                              val append :
                                lower_part:'a t ->
                                upper_part:'a t ->
                                [ `Ok of 'a t | `Overlapping_key_ranges ]
                              val subrange :
                                'a t ->
                                lower_bound:id Base__.Maybe_bound.t ->
                                upper_bound:id Base__.Maybe_bound.t -> 'a t
                              val fold_range_inclusive :
                                'a t ->
                                min:id ->
                                max:id ->
                                init:'->
                                f:(key:id -> data:'-> '-> 'b) -> 'b
                              val range_to_alist :
                                'a t -> min:id -> max:id -> (id * 'a) List.t
                              val closest_key :
                                'a t ->
                                [ `Greater_or_equal_to
                                | `Greater_than
                                | `Less_or_equal_to
                                | `Less_than ] -> id -> (id * 'a) Option.t
                              val nth :
                                'a t -> Monoid.Int.t -> (id * 'a) Option.t
                              val nth_exn : 'a t -> Monoid.Int.t -> id * 'a
                              val rank : 'a t -> id -> Monoid.Int.t Option.t
                              val to_tree : 'a t -> 'Tree.t
                              val to_sequence :
                                ?order:[ `Decreasing_key | `Increasing_key ] ->
                                ?keys_greater_or_equal_to:id ->
                                ?keys_less_or_equal_to:id ->
                                'a t -> (id * 'a) Base__.Sequence.t
                              val obs :
                                id Core_kernel__.Quickcheck.Observer.t ->
                                'Core_kernel__.Quickcheck.Observer.t ->
                                'v t Core_kernel__.Quickcheck.Observer.t
                              val shrinker :
                                id Core_kernel__.Quickcheck.Shrinker.t ->
                                'Core_kernel__.Quickcheck.Shrinker.t ->
                                'v t Core_kernel__.Quickcheck.Shrinker.t
                              module Provide_of_sexp :
                                functor
                                  (Key : sig
                                           val t_of_sexp :
                                             Sexplib.Sexp.t -> id
                                         end->
                                  sig
                                    val t_of_sexp :
                                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                                      Sexplib.Sexp.t -> 'v_x__018_ t
                                  end
                              module Provide_bin_io :
                                functor
                                  (Key : sig
                                           val bin_t :
                                             id Bin_prot.Type_class.t
                                           val bin_read_t :
                                             id Bin_prot.Read.reader
                                           val __bin_read_t__ :
                                             (Core_kernel__.Import.int -> id)
                                             Bin_prot.Read.reader
                                           val bin_reader_t :
                                             id Bin_prot.Type_class.reader
                                           val bin_size_t :
                                             id Bin_prot.Size.sizer
                                           val bin_write_t :
                                             id Bin_prot.Write.writer
                                           val bin_writer_t :
                                             id Bin_prot.Type_class.writer
                                           val bin_shape_t : Bin_prot.Shape.t
                                         end->
                                  sig
                                    val bin_shape_t :
                                      Bin_prot.Shape.t -> Bin_prot.Shape.t
                                    val bin_size_t :
                                      ('a, 'a t) Bin_prot.Size.sizer1
                                    val bin_write_t :
                                      ('a, 'a t) Bin_prot.Write.writer1
                                    val bin_read_t :
                                      ('a, 'a t) Bin_prot.Read.reader1
                                    val __bin_read_t__ :
                                      ('a, Monoid.Int.t -> 'a t)
                                      Bin_prot.Read.reader1
                                    val bin_writer_t :
                                      ('a, 'a t)
                                      Bin_prot.Type_class.S1.writer
                                    val bin_reader_t :
                                      ('a, 'a t)
                                      Bin_prot.Type_class.S1.reader
                                    val bin_t :
                                      ('a, 'a t) Bin_prot.Type_class.S1.t
                                  end
                              module Provide_hash :
                                functor
                                  (Key : sig
                                           val hash_fold_t :
                                             Base__.Hash.state ->
                                             id -> Base__.Hash.state
                                         end->
                                  sig
                                    val hash_fold_t :
                                      (Ppx_hash_lib.Std.Hash.state ->
                                       '-> Ppx_hash_lib.Std.Hash.state) ->
                                      Ppx_hash_lib.Std.Hash.state ->
                                      'a t -> Ppx_hash_lib.Std.Hash.state
                                  end
                              val t_of_sexp :
                                (Base__.Sexplib.Sexp.t -> 'a) ->
                                Base__.Sexplib.Sexp.t -> 'a t
                              val sexp_of_t :
                                ('-> Base__.Sexplib.Sexp.t) ->
                                'a t -> Base__.Sexplib.Sexp.t
                              val bin_shape_t :
                                Bin_prot.Shape.t -> Bin_prot.Shape.t
                              val bin_size_t :
                                ('a, 'a t) Bin_prot.Size.sizer1
                              val bin_write_t :
                                ('a, 'a t) Bin_prot.Write.writer1
                              val bin_read_t :
                                ('a, 'a t) Bin_prot.Read.reader1
                              val __bin_read_t__ :
                                ('a, Monoid.Int.t -> 'a t)
                                Bin_prot.Read.reader1
                              val bin_writer_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.writer
                              val bin_reader_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.reader
                              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                            end
                          module Set :
                            sig
                              module Elt :
                                sig
                                  type t = id
                                  val bin_t : t Bin_prot.Type_class.t
                                  val bin_read_t : t Bin_prot.Read.reader
                                  val __bin_read_t__ :
                                    (Core_kernel__.Import.int -> t)
                                    Bin_prot.Read.reader
                                  val bin_reader_t :
                                    t Bin_prot.Type_class.reader
                                  val bin_size_t : t Bin_prot.Size.sizer
                                  val bin_write_t : t Bin_prot.Write.writer
                                  val bin_writer_t :
                                    t Bin_prot.Type_class.writer
                                  val bin_shape_t : Bin_prot.Shape.t
                                  val t_of_sexp : Sexplib.Sexp.t -> t
                                  val sexp_of_t : t -> Sexplib.Sexp.t
                                  type comparator_witness =
                                      Map.Key.comparator_witness
                                  val comparator :
                                    (t, comparator_witness)
                                    Core_kernel__.Comparator.comparator
                                end
                              module Tree :
                                sig
                                  type t =
                                      (id, comparator_witness)
                                      Core_kernel__.Core_set_intf.Tree.t
                                  val compare :
                                    t -> t -> Core_kernel__.Import.int
                                  val length : t -> Monoid.Int.t
                                  val is_empty : t -> bool
                                  val iter :
                                    t ->
                                    f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
                                  val fold :
                                    t ->
                                    init:'accum ->
                                    f:('accum -> id -> 'accum) -> 'accum
                                  val fold_result :
                                    t ->
                                    init:'accum ->
                                    f:('accum ->
                                       id -> ('accum, 'e) Base__.Result.t) ->
                                    ('accum, 'e) Base__.Result.t
                                  val exists : t -> f:(id -> bool) -> bool
                                  val for_all : t -> f:(id -> bool) -> bool
                                  val count :
                                    t -> f:(id -> bool) -> Monoid.Int.t
                                  val sum :
                                    (module Base__.Commutative_group.S with type t = 'sum) ->
                                    t -> f:(id -> 'sum) -> 'sum
                                  val find :
                                    t -> f:(id -> bool) -> id Option.t
                                  val find_map :
                                    t -> f:(id -> 'Option.t) -> 'Option.t
                                  val to_list : t -> id List.t
                                  val to_array : t -> id array
                                  val invariants : t -> bool
                                  val mem : t -> id -> bool
                                  val add : t -> id -> t
                                  val remove : t -> id -> t
                                  val union : t -> t -> t
                                  val inter : t -> t -> t
                                  val diff : t -> t -> t
                                  val symmetric_diff :
                                    t ->
                                    t ->
                                    (id, id) Base__.Either.t
                                    Base__.Sequence.t
                                  val compare_direct : t -> t -> Monoid.Int.t
                                  val equal : t -> t -> bool
                                  val is_subset : t -> of_:t -> bool
                                  val subset : t -> t -> bool
                                  val fold_until :
                                    t ->
                                    init:'->
                                    f:('->
                                       id ->
                                       ('b, 'stop)
                                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                                    ('b, 'stop)
                                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                                  val fold_right :
                                    t -> init:'-> f:(id -> '-> 'b) -> 'b
                                  val iter2 :
                                    t ->
                                    t ->
                                    f:([ `Both of id * id
                                       | `Left of id
                                       | `Right of id ] -> Monoid.Unit.t) ->
                                    Monoid.Unit.t
                                  val filter : t -> f:(id -> bool) -> t
                                  val partition_tf :
                                    t -> f:(id -> bool) -> t * t
                                  val elements : t -> id List.t
                                  val min_elt : t -> id Option.t
                                  val min_elt_exn : t -> id
                                  val max_elt : t -> id Option.t
                                  val max_elt_exn : t -> id
                                  val choose : t -> id Option.t
                                  val choose_exn : t -> id
                                  val split : t -> id -> t * id Option.t * t
                                  val group_by :
                                    t -> equiv:(id -> id -> bool) -> t List.t
                                  val find_exn : t -> f:(id -> bool) -> id
                                  val find_index :
                                    t -> Monoid.Int.t -> id Option.t
                                  val nth : t -> Monoid.Int.t -> id Option.t
                                  val remove_index : t -> Monoid.Int.t -> t
                                  val to_tree : t -> t
                                  val to_sequence :
                                    ?order:[ `Decreasing | `Increasing ] ->
                                    ?greater_or_equal_to:id ->
                                    ?less_or_equal_to:id ->
                                    t -> id Base__.Sequence.t
                                  val merge_to_sequence :
                                    ?order:[ `Decreasing | `Increasing ] ->
                                    ?greater_or_equal_to:id ->
                                    ?less_or_equal_to:id ->
                                    t ->
                                    t ->
                                    (id, id)
                                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                                    Base__.Sequence.t
                                  val to_map :
                                    t ->
                                    f:(id -> 'data) ->
                                    (id, 'data, comparator_witness)
                                    Core_kernel__.Core_set_intf.Map.t
                                  val obs :
                                    id Core_kernel__.Quickcheck.Observer.t ->
                                    t Core_kernel__.Quickcheck.Observer.t
                                  val shrinker :
                                    id Core_kernel__.Quickcheck.Shrinker.t ->
                                    t Core_kernel__.Quickcheck.Shrinker.t
                                  val empty : t
                                  val singleton : id -> t
                                  val union_list : t List.t -> t
                                  val of_list : id List.t -> t
                                  val of_array : id array -> t
                                  val of_sorted_array :
                                    id array -> t Base__.Or_error.t
                                  val of_sorted_array_unchecked :
                                    id array -> t
                                  val of_increasing_iterator_unchecked :
                                    len:Monoid.Int.t ->
                                    f:(Monoid.Int.t -> id) -> t
                                  val stable_dedup_list :
                                    id List.t -> id List.t
                                  val map :
                                    ('a, 'b)
                                    Core_kernel__.Core_set_intf.Tree.t ->
                                    f:('-> id) -> t
                                  val filter_map :
                                    ('a, 'b)
                                    Core_kernel__.Core_set_intf.Tree.t ->
                                    f:('-> id Option.t) -> t
                                  val of_tree : t -> t
                                  val of_hash_set :
                                    id Core_kernel__.Hash_set.t -> t
                                  val of_hashtbl_keys :
                                    (id, 'a) Core_kernel__.Core_hashtbl.t ->
                                    t
                                  val of_map_keys :
                                    (id, 'a, comparator_witness)
                                    Core_kernel__.Core_set_intf.Map.t -> 
                                    t
                                  val gen :
                                    id Core_kernel__.Quickcheck.Generator.t ->
                                    t Core_kernel__.Quickcheck.Generator.t
                                  module Provide_of_sexp :
                                    functor
                                      (Elt : sig
                                               val t_of_sexp :
                                                 Sexplib.Sexp.t -> id
                                             end->
                                      sig
                                        val t_of_sexp : Sexplib.Sexp.t -> t
                                      end
                                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                                end
                              type t = (id, comparator_witness) Base.Set.t
                              val compare :
                                t -> t -> Core_kernel__.Import.int
                              val length : t -> Monoid.Int.t
                              val is_empty : t -> bool
                              val iter :
                                t -> f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
                              val fold :
                                t ->
                                init:'accum ->
                                f:('accum -> id -> 'accum) -> 'accum
                              val fold_result :
                                t ->
                                init:'accum ->
                                f:('accum ->
                                   id -> ('accum, 'e) Base__.Result.t) ->
                                ('accum, 'e) Base__.Result.t
                              val exists : t -> f:(id -> bool) -> bool
                              val for_all : t -> f:(id -> bool) -> bool
                              val count : t -> f:(id -> bool) -> Monoid.Int.t
                              val sum :
                                (module Base__.Commutative_group.S with type t = 'sum) ->
                                t -> f:(id -> 'sum) -> 'sum
                              val find : t -> f:(id -> bool) -> id Option.t
                              val find_map :
                                t -> f:(id -> 'Option.t) -> 'Option.t
                              val to_list : t -> id List.t
                              val to_array : t -> id array
                              val invariants : t -> bool
                              val mem : t -> id -> bool
                              val add : t -> id -> t
                              val remove : t -> id -> t
                              val union : t -> t -> t
                              val inter : t -> t -> t
                              val diff : t -> t -> t
                              val symmetric_diff :
                                t ->
                                t ->
                                (id, id) Base__.Either.t Base__.Sequence.t
                              val compare_direct : t -> t -> Monoid.Int.t
                              val equal : t -> t -> bool
                              val is_subset : t -> of_:t -> bool
                              val subset : t -> t -> bool
                              val fold_until :
                                t ->
                                init:'->
                                f:('->
                                   id ->
                                   ('b, 'stop)
                                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                                ('b, 'stop)
                                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                              val fold_right :
                                t -> init:'-> f:(id -> '-> 'b) -> 'b
                              val iter2 :
                                t ->
                                t ->
                                f:([ `Both of id * id
                                   | `Left of id
                                   | `Right of id ] -> Monoid.Unit.t) ->
                                Monoid.Unit.t
                              val filter : t -> f:(id -> bool) -> t
                              val partition_tf : t -> f:(id -> bool) -> t * t
                              val elements : t -> id List.t
                              val min_elt : t -> id Option.t
                              val min_elt_exn : t -> id
                              val max_elt : t -> id Option.t
                              val max_elt_exn : t -> id
                              val choose : t -> id Option.t
                              val choose_exn : t -> id
                              val split : t -> id -> t * id Option.t * t
                              val group_by :
                                t -> equiv:(id -> id -> bool) -> t List.t
                              val find_exn : t -> f:(id -> bool) -> id
                              val find_index :
                                t -> Monoid.Int.t -> id Option.t
                              val nth : t -> Monoid.Int.t -> id Option.t
                              val remove_index : t -> Monoid.Int.t -> t
                              val to_tree : t -> Tree.t
                              val to_sequence :
                                ?order:[ `Decreasing | `Increasing ] ->
                                ?greater_or_equal_to:id ->
                                ?less_or_equal_to:id ->
                                t -> id Base__.Sequence.t
                              val merge_to_sequence :
                                ?order:[ `Decreasing | `Increasing ] ->
                                ?greater_or_equal_to:id ->
                                ?less_or_equal_to:id ->
                                t ->
                                t ->
                                (id, id)
                                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                                Base__.Sequence.t
                              val to_map :
                                t ->
                                f:(id -> 'data) ->
                                (id, 'data, comparator_witness)
                                Core_kernel__.Core_set_intf.Map.t
                              val obs :
                                id Core_kernel__.Quickcheck.Observer.t ->
                                t Core_kernel__.Quickcheck.Observer.t
                              val shrinker :
                                id Core_kernel__.Quickcheck.Shrinker.t ->
                                t Core_kernel__.Quickcheck.Shrinker.t
                              val empty : t
                              val singleton : id -> t
                              val union_list : t List.t -> t
                              val of_list : id List.t -> t
                              val of_array : id array -> t
                              val of_sorted_array :
                                id array -> t Base__.Or_error.t
                              val of_sorted_array_unchecked : id array -> t
                              val of_increasing_iterator_unchecked :
                                len:Monoid.Int.t ->
                                f:(Monoid.Int.t -> id) -> t
                              val stable_dedup_list : id List.t -> id List.t
                              val map :
                                ('a, 'b) Base.Set.t -> f:('-> id) -> t
                              val filter_map :
                                ('a, 'b) Base.Set.t ->
                                f:('-> id Option.t) -> t
                              val of_tree : Tree.t -> t
                              val of_hash_set :
                                id Core_kernel__.Hash_set.t -> t
                              val of_hashtbl_keys :
                                (id, 'a) Core_kernel__.Core_hashtbl.t -> t
                              val of_map_keys :
                                (id, 'a, comparator_witness)
                                Core_kernel__.Core_set_intf.Map.t -> 
                                t
                              val gen :
                                id Core_kernel__.Quickcheck.Generator.t ->
                                t Core_kernel__.Quickcheck.Generator.t
                              module Provide_of_sexp :
                                functor
                                  (Elt : sig
                                           val t_of_sexp :
                                             Sexplib.Sexp.t -> id
                                         end->
                                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
                              module Provide_bin_io :
                                functor
                                  (Elt : sig
                                           val bin_t :
                                             id Bin_prot.Type_class.t
                                           val bin_read_t :
                                             id Bin_prot.Read.reader
                                           val __bin_read_t__ :
                                             (Core_kernel__.Import.int -> id)
                                             Bin_prot.Read.reader
                                           val bin_reader_t :
                                             id Bin_prot.Type_class.reader
                                           val bin_size_t :
                                             id Bin_prot.Size.sizer
                                           val bin_write_t :
                                             id Bin_prot.Write.writer
                                           val bin_writer_t :
                                             id Bin_prot.Type_class.writer
                                           val bin_shape_t : Bin_prot.Shape.t
                                         end->
                                  sig
                                    val bin_size_t : t Bin_prot.Size.sizer
                                    val bin_write_t : t Bin_prot.Write.writer
                                    val bin_read_t : t Bin_prot.Read.reader
                                    val __bin_read_t__ :
                                      (Monoid.Int.t -> t)
                                      Bin_prot.Read.reader
                                    val bin_shape_t : Bin_prot.Shape.t
                                    val bin_writer_t :
                                      t Bin_prot.Type_class.writer
                                    val bin_reader_t :
                                      t Bin_prot.Type_class.reader
                                    val bin_t : t Bin_prot.Type_class.t
                                  end
                              module Provide_hash :
                                functor
                                  (Elt : sig
                                           val hash_fold_t :
                                             Base__.Hash.state ->
                                             id -> Base__.Hash.state
                                         end->
                                  sig
                                    val hash_fold_t :
                                      Ppx_hash_lib.Std.Hash.state ->
                                      t -> Ppx_hash_lib.Std.Hash.state
                                    val hash :
                                      t -> Ppx_hash_lib.Std.Hash.hash_value
                                  end
                              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (Monoid.Int.t -> t) Bin_prot.Read.reader
                              val bin_shape_t : Bin_prot.Shape.t
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_t : t Bin_prot.Type_class.t
                            end
                          val hash : t -> Core_kernel__.Import.int
                          val hashable :
                            t Core_kernel__.Hashable.Hashtbl.Hashable.t
                          module Table :
                            sig
                              type key = t
                              type ('a, 'b) hashtbl =
                                  ('a, 'b) Id.Table.hashtbl
                              type 'b t = (key, 'b) hashtbl
                              val sexp_of_t :
                                ('-> Sexplib.Sexp.t) ->
                                'b t -> Sexplib.Sexp.t
                              type ('a, 'b) t_ = 'b t
                              type 'a key_ = key
                              val hashable :
                                key
                                Core_kernel__.Core_hashtbl_intf.Hashable.t
                              val invariant :
                                'Base__.Invariant_intf.inv ->
                                'a t Base__.Invariant_intf.inv
                              val create :
                                (key, 'b, Monoid.Unit.t -> 'b t)
                                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                              val of_alist :
                                (key, 'b,
                                 (key * 'b) List.t ->
                                 [ `Duplicate_key of key | `Ok of 'b t ])
                                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                              val of_alist_report_all_dups :
                                (key, 'b,
                                 (key * 'b) List.t ->
                                 [ `Duplicate_keys of key List.t
                                 | `Ok of 'b t ])
                                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                              val of_alist_or_error :
                                (key, 'b,
                                 (key * 'b) List.t -> 'b t Base__.Or_error.t)
                                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                              val of_alist_exn :
                                (key, 'b, (key * 'b) List.t -> 'b t)
                                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                              val of_alist_multi :
                                (key, 'List.t,
                                 (key * 'b) List.t -> 'List.t t)
                                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                              val create_mapped :
                                (key, 'b,
                                 get_key:('-> key) ->
                                 get_data:('-> 'b) ->
                                 'List.t ->
                                 [ `Duplicate_keys of key List.t
                                 | `Ok of 'b t ])
                                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                              val create_with_key :
                                (key, 'r,
                                 get_key:('-> key) ->
                                 'List.t ->
                                 [ `Duplicate_keys of key List.t
                                 | `Ok of 'r t ])
                                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                              val create_with_key_or_error :
                                (key, 'r,
                                 get_key:('-> key) ->
                                 'List.t -> 'r t Base__.Or_error.t)
                                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                              val create_with_key_exn :
                                (key, 'r,
                                 get_key:('-> key) -> 'List.t -> 'r t)
                                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                              val group :
                                (key, 'b,
                                 get_key:('-> key) ->
                                 get_data:('-> 'b) ->
                                 combine:('-> '-> 'b) ->
                                 'List.t -> 'b t)
                                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                              val clear : 'a t -> Monoid.Unit.t
                              val copy : 'b t -> 'b t
                              val fold :
                                'b t ->
                                init:'->
                                f:(key:key -> data:'-> '-> 'c) -> 'c
                              val iter_keys :
                                'a t ->
                                f:(key -> Monoid.Unit.t) -> Monoid.Unit.t
                              val iter :
                                'b t ->
                                f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                              val iteri :
                                'b t ->
                                f:(key:key -> data:'-> Monoid.Unit.t) ->
                                Monoid.Unit.t
                              val iter_vals :
                                'b t ->
                                f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                              val existsi :
                                'b t ->
                                f:(key:key -> data:'-> bool) -> bool
                              val exists : 'b t -> f:('-> bool) -> bool
                              val for_alli :
                                'b t ->
                                f:(key:key -> data:'-> bool) -> bool
                              val for_all : 'b t -> f:('-> bool) -> bool
                              val counti :
                                'b t ->
                                f:(key:key -> data:'-> bool) ->
                                Monoid.Int.t
                              val count :
                                'b t -> f:('-> bool) -> Monoid.Int.t
                              val length : 'a t -> Monoid.Int.t
                              val is_empty : 'a t -> bool
                              val mem : 'a t -> key -> bool
                              val remove : 'a t -> key -> Monoid.Unit.t
                              val replace :
                                'b t -> key:key -> data:'-> Monoid.Unit.t
                              val set :
                                'b t -> key:key -> data:'-> Monoid.Unit.t
                              val add :
                                'b t ->
                                key:key -> data:'-> [ `Duplicate | `Ok ]
                              val add_or_error :
                                'b t ->
                                key:key ->
                                data:'-> Monoid.Unit.t Base__.Or_error.t
                              val add_exn :
                                'b t -> key:key -> data:'-> Monoid.Unit.t
                              val change :
                                'b t ->
                                key ->
                                f:('Option.t -> 'Option.t) ->
                                Monoid.Unit.t
                              val update :
                                'b t ->
                                key -> f:('Option.t -> 'b) -> Monoid.Unit.t
                              val add_multi :
                                'List.t t ->
                                key:key -> data:'-> Monoid.Unit.t
                              val remove_multi :
                                'List.t t -> key -> Monoid.Unit.t
                              val map : 'b t -> f:('-> 'c) -> 'c t
                              val mapi :
                                'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                              val filter_map :
                                'b t -> f:('-> 'Option.t) -> 'c t
                              val filter_mapi :
                                'b t ->
                                f:(key:key -> data:'-> 'Option.t) -> 'c t
                              val filter_keys :
                                'b t -> f:(key -> bool) -> 'b t
                              val filter : 'b t -> f:('-> bool) -> 'b t
                              val filteri :
                                'b t ->
                                f:(key:key -> data:'-> bool) -> 'b t
                              val partition_map :
                                'b t ->
                                f:('-> [ `Fst of '| `Snd of 'd ]) ->
                                'c t * 'd t
                              val partition_mapi :
                                'b t ->
                                f:(key:key ->
                                   data:'-> [ `Fst of '| `Snd of 'd ]) ->
                                'c t * 'd t
                              val partition_tf :
                                'b t -> f:('-> bool) -> 'b t * 'b t
                              val partitioni_tf :
                                'b t ->
                                f:(key:key -> data:'-> bool) -> 'b t * 'b t
                              val find_or_add :
                                'b t ->
                                key -> default:(Monoid.Unit.t -> 'b) -> 'b
                              val find : 'b t -> key -> 'Option.t
                              val find_exn : 'b t -> key -> 'b
                              val find_and_call :
                                'b t ->
                                key ->
                                if_found:('-> 'c) ->
                                if_not_found:(key -> 'c) -> 'c
                              val find_and_remove :
                                'b t -> key -> 'Option.t
                              val merge :
                                'a t ->
                                'b t ->
                                f:(key:key ->
                                   [ `Both of 'a * 'b
                                   | `Left of 'a
                                   | `Right of 'b ] -> 'Option.t) ->
                                'c t
                              type 'a merge_into_action =
                                  Remove
                                | Set_to of 'a
                              val merge_into :
                                src:'a t ->
                                dst:'b t ->
                                f:(key:key ->
                                   '-> 'Option.t -> 'b merge_into_action) ->
                                Monoid.Unit.t
                              val keys : 'a t -> key List.t
                              val data : 'b t -> 'List.t
                              val filter_keys_inplace :
                                'a t -> f:(key -> bool) -> Monoid.Unit.t
                              val filter_inplace :
                                'b t -> f:('-> bool) -> Monoid.Unit.t
                              val filteri_inplace :
                                'b t ->
                                f:(key:key -> data:'-> bool) ->
                                Monoid.Unit.t
                              val map_inplace :
                                'b t -> f:('-> 'b) -> Monoid.Unit.t
                              val mapi_inplace :
                                'b t ->
                                f:(key:key -> data:'-> 'b) -> Monoid.Unit.t
                              val filter_map_inplace :
                                'b t ->
                                f:('-> 'Option.t) -> Monoid.Unit.t
                              val filter_mapi_inplace :
                                'b t ->
                                f:(key:key -> data:'-> 'Option.t) ->
                                Monoid.Unit.t
                              val replace_all :
                                'b t -> f:('-> 'b) -> Monoid.Unit.t
                              val replace_alli :
                                'b t ->
                                f:(key:key -> data:'-> 'b) -> Monoid.Unit.t
                              val filter_replace_all :
                                'b t ->
                                f:('-> 'Option.t) -> Monoid.Unit.t
                              val filter_replace_alli :
                                'b t ->
                                f:(key:key -> data:'-> 'Option.t) ->
                                Monoid.Unit.t
                              val equal :
                                'b t -> 'b t -> ('-> '-> bool) -> bool
                              val similar :
                                'b1 t ->
                                'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                              val to_alist : 'b t -> (key * 'b) List.t
                              val validate :
                                name:(key -> Monoid.String.t) ->
                                'Base__.Validate.check ->
                                'b t Base__.Validate.check
                              val incr :
                                ?by:Monoid.Int.t ->
                                ?remove_if_zero:bool ->
                                Monoid.Int.t t -> key -> Monoid.Unit.t
                              val decr :
                                ?by:Monoid.Int.t ->
                                ?remove_if_zero:bool ->
                                Monoid.Int.t t -> key -> Monoid.Unit.t
                              module Provide_of_sexp :
                                functor
                                  (Key : sig
                                           val t_of_sexp :
                                             Sexplib.Sexp.t -> key
                                         end->
                                  sig
                                    val t_of_sexp :
                                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                                      Sexplib.Sexp.t -> 'v_x__001_ t
                                  end
                              module Provide_bin_io :
                                functor
                                  (Key : sig
                                           val bin_t :
                                             key Bin_prot.Type_class.t
                                           val bin_read_t :
                                             key Bin_prot.Read.reader
                                           val __bin_read_t__ :
                                             (Core_kernel__.Import.int -> key)
                                             Bin_prot.Read.reader
                                           val bin_reader_t :
                                             key Bin_prot.Type_class.reader
                                           val bin_size_t :
                                             key Bin_prot.Size.sizer
                                           val bin_write_t :
                                             key Bin_prot.Write.writer
                                           val bin_writer_t :
                                             key Bin_prot.Type_class.writer
                                           val bin_shape_t : Bin_prot.Shape.t
                                         end->
                                  sig
                                    val bin_t :
                                      'Bin_prot.Type_class.t ->
                                      'a t Bin_prot.Type_class.t
                                    val bin_read_t :
                                      'Bin_prot.Read.reader ->
                                      'a t Bin_prot.Read.reader
                                    val __bin_read_t__ :
                                      'Bin_prot.Read.reader ->
                                      (Core_kernel__.Import.int -> 'a t)
                                      Bin_prot.Read.reader
                                    val bin_reader_t :
                                      'Bin_prot.Type_class.reader ->
                                      'a t Bin_prot.Type_class.reader
                                    val bin_size_t :
                                      'Bin_prot.Size.sizer ->
                                      'a t Bin_prot.Size.sizer
                                    val bin_write_t :
                                      'Bin_prot.Write.writer ->
                                      'a t Bin_prot.Write.writer
                                    val bin_writer_t :
                                      'Bin_prot.Type_class.writer ->
                                      'a t Bin_prot.Type_class.writer
                                    val bin_shape_t :
                                      Bin_prot.Shape.t -> Bin_prot.Shape.t
                                  end
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__002_) ->
                                Sexplib.Sexp.t -> 'v_x__002_ t
                              val bin_shape_t :
                                Bin_prot.Shape.t -> Bin_prot.Shape.t
                              val bin_size_t :
                                ('a, 'a t) Bin_prot.Size.sizer1
                              val bin_write_t :
                                ('a, 'a t) Bin_prot.Write.writer1
                              val bin_read_t :
                                ('a, 'a t) Bin_prot.Read.reader1
                              val __bin_read_t__ :
                                ('a, Monoid.Int.t -> 'a t)
                                Bin_prot.Read.reader1
                              val bin_writer_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.writer
                              val bin_reader_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.reader
                              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                            end
                          module Hash_set :
                            sig
                              type elt = t
                              type t = elt Core_kernel__.Hash_set.t
                              val sexp_of_t : t -> Sexplib.Sexp.t
                              type 'a t_ = t
                              type 'a elt_ = elt
                              val create :
                                ('a, Monoid.Unit.t -> t)
                                Core_kernel__.Hash_set_intf.create_options_without_hashable
                              val of_list :
                                ('a, elt List.t -> t)
                                Core_kernel__.Hash_set_intf.create_options_without_hashable
                              module Provide_of_sexp :
                                functor
                                  (X : sig
                                         val t_of_sexp :
                                           Sexplib.Sexp.t -> elt
                                       end->
                                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
                              module Provide_bin_io :
                                functor
                                  (X : sig
                                         val bin_t :
                                           elt Bin_prot.Type_class.t
                                         val bin_read_t :
                                           elt Bin_prot.Read.reader
                                         val __bin_read_t__ :
                                           (Core_kernel__.Import.int -> elt)
                                           Bin_prot.Read.reader
                                         val bin_reader_t :
                                           elt Bin_prot.Type_class.reader
                                         val bin_size_t :
                                           elt Bin_prot.Size.sizer
                                         val bin_write_t :
                                           elt Bin_prot.Write.writer
                                         val bin_writer_t :
                                           elt Bin_prot.Type_class.writer
                                         val bin_shape_t : Bin_prot.Shape.t
                                       end->
                                  sig
                                    val bin_t : t Bin_prot.Type_class.t
                                    val bin_read_t : t Bin_prot.Read.reader
                                    val __bin_read_t__ :
                                      (Core_kernel__.Import.int -> t)
                                      Bin_prot.Read.reader
                                    val bin_reader_t :
                                      t Bin_prot.Type_class.reader
                                    val bin_size_t : t Bin_prot.Size.sizer
                                    val bin_write_t : t Bin_prot.Write.writer
                                    val bin_writer_t :
                                      t Bin_prot.Type_class.writer
                                    val bin_shape_t : Bin_prot.Shape.t
                                  end
                              val t_of_sexp : Sexplib.Sexp.t -> t
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (Monoid.Int.t -> t) Bin_prot.Read.reader
                              val bin_shape_t : Bin_prot.Shape.t
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_t : t Bin_prot.Type_class.t
                            end
                          module Hash_queue :
                            sig
                              module Key :
                                sig
                                  type t = id
                                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                                  val compare : t -> t -> Monoid.Int.t
                                  val hash : t -> Monoid.Int.t
                                end
                              type 'a t
                              val sexp_of_t :
                                ('-> Sexplib.Sexp.t) ->
                                'a t -> Sexplib.Sexp.t
                              val length : 'a t -> Monoid.Int.t
                              val is_empty : 'a t -> bool
                              val iter :
                                'a t ->
                                f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                              val fold :
                                'a t ->
                                init:'accum ->
                                f:('accum -> '-> 'accum) -> 'accum
                              val fold_result :
                                'a t ->
                                init:'accum ->
                                f:('accum ->
                                   '-> ('accum, 'e) Base__.Result.t) ->
                                ('accum, 'e) Base__.Result.t
                              val fold_until :
                                'a t ->
                                init:'accum ->
                                f:('accum ->
                                   '->
                                   ('accum, 'stop)
                                   Base.Container_intf.Continue_or_stop.t) ->
                                ('accum, 'stop)
                                Base.Container_intf.Finished_or_stopped_early.t
                              val exists : 'a t -> f:('-> bool) -> bool
                              val for_all : 'a t -> f:('-> bool) -> bool
                              val count :
                                'a t -> f:('-> bool) -> Monoid.Int.t
                              val sum :
                                (module Base__.Commutative_group.S with type t = 'sum) ->
                                'a t -> f:('-> 'sum) -> 'sum
                              val find :
                                'a t -> f:('-> bool) -> 'Option.t
                              val find_map :
                                'a t -> f:('-> 'Option.t) -> 'Option.t
                              val to_list : 'a t -> 'List.t
                              val to_array : 'a t -> 'a array
                              val min_elt :
                                'a t ->
                                cmp:('-> '-> Monoid.Int.t) -> 'Option.t
                              val max_elt :
                                'a t ->
                                cmp:('-> '-> Monoid.Int.t) -> 'Option.t
                              val invariant :
                                'a t -> Core_kernel__.Import.unit
                              val create :
                                ?growth_allowed:Core_kernel__.Import.bool ->
                                ?size:Core_kernel__.Import.int ->
                                Core_kernel__.Import.unit -> 'a t
                              val clear : 'a t -> Core_kernel__.Import.unit
                              val mem :
                                'a t -> id -> Core_kernel__.Import.bool
                              val lookup :
                                'a t -> id -> 'Core_kernel__.Import.option
                              val lookup_exn : 'a t -> id -> 'a
                              val enqueue :
                                'a t ->
                                id -> '-> [ `Key_already_present | `Ok ]
                              val enqueue_exn :
                                'a t -> id -> '-> Core_kernel__.Import.unit
                              val lookup_and_move_to_back :
                                'a t -> id -> 'Core_kernel__.Import.option
                              val lookup_and_move_to_back_exn :
                                'a t -> id -> 'a
                              val first :
                                'a t -> 'Core_kernel__.Import.option
                              val first_with_key :
                                'a t -> (id * 'a) Core_kernel__.Import.option
                              val keys : 'a t -> id Core_kernel__.Import.list
                              val dequeue :
                                'a t -> 'Core_kernel__.Import.option
                              val dequeue_exn : 'a t -> 'a
                              val dequeue_with_key :
                                'a t -> (id * 'a) Core_kernel__.Import.option
                              val dequeue_with_key_exn : 'a t -> id * 'a
                              val dequeue_all :
                                'a t ->
                                f:('-> Core_kernel__.Import.unit) ->
                                Core_kernel__.Import.unit
                              val remove :
                                'a t -> id -> [ `No_such_key | `Ok ]
                              val remove_exn :
                                'a t -> id -> Core_kernel__.Import.unit
                              val replace :
                                'a t -> id -> '-> [ `No_such_key | `Ok ]
                              val replace_exn :
                                'a t -> id -> '-> Core_kernel__.Import.unit
                              val iteri :
                                'a t ->
                                f:(key:id ->
                                   data:'-> Core_kernel__.Import.unit) ->
                                Core_kernel__.Import.unit
                              val foldi :
                                'a t ->
                                init:'->
                                f:('-> key:id -> data:'-> 'b) -> 'b
                            end
                          val pp :
                            Base__.Import.Caml.Format.formatter ->
                            t -> Monoid.Unit.t
                        end
                      val global : Monads.Std.Monad.State.Multi.S.id
                      val fork : unit -> unit t
                      val switch :
                        Monads.Std.Monad.State.Multi.S.id -> unit t
                      val parent :
                        unit -> Monads.Std.Monad.State.Multi.S.id t
                      val ancestor :
                        Monads.Std.Monad.State.Multi.S.id list ->
                        Monads.Std.Monad.State.Multi.S.id t
                      val current :
                        unit -> Monads.Std.Monad.State.Multi.S.id t
                      val kill : Monads.Std.Monad.State.Multi.S.id -> unit t
                      val forks :
                        unit ->
                        Monads.Std.Monad.State.Multi.S.id
                        Core_kernel.Std.Sequence.t t
                      val status :
                        Monads.Std.Monad.State.Multi.S.id ->
                        Monads.Std.Monad.State.Multi.status t
                      val lift : 'a m -> 'a t
                      val run : 'a t -> 'a e
                      val void : 'a t -> Monoid.Unit.t t
                      val sequence :
                        Monoid.Unit.t t List.t -> Monoid.Unit.t t
                      val forever : 'a t -> 'b t
                      module Fn :
                        sig
                          val id : '-> 'a t
                          val ignore : 'a t -> Monoid.Unit.t t
                          val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                          val non : ('-> bool t) -> '-> bool t
                          val apply_n_times :
                            n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                          val compose :
                            ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                        end
                      module Pair :
                        sig
                          val fst : ('a * 'b) t -> 'a t
                          val snd : ('a * 'b) t -> 'b t
                        end
                      module Triple :
                        sig
                          val fst : ('a * 'b * 'c) t -> 'a t
                          val snd : ('a * 'b * 'c) t -> 'b t
                          val trd : ('a * 'b * 'c) t -> 'c t
                        end
                      module Lift :
                        sig
                          val nullary : '-> 'a t
                          val unary : ('-> 'b) -> 'a t -> 'b t
                          val binary :
                            ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                          val ternary :
                            ('-> '-> '-> 'd) ->
                            'a t -> 'b t -> 'c t -> 'd t
                          val quaternary :
                            ('-> '-> '-> '-> 'e) ->
                            'a t -> 'b t -> 'c t -> 'd t -> 'e t
                          val quinary :
                            ('-> '-> '-> '-> '-> 'f) ->
                            'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                        end
                      module Exn :
                        sig
                          val expect :
                            ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                            f:(Monoid.Unit.t -> 'a t) ->
                            catch:(exn -> 'a t) -> 'a t
                        end
                      module Collection :
                        sig
                          module type S =
                            sig
                              type 'a t
                              val all : 'a t t -> 'a t t
                              val all_ignore : 'a t t -> Monoid.Unit.t t
                              val sequence :
                                Monoid.Unit.t t t -> Monoid.Unit.t t
                              val map : 'a t -> f:('-> 'b t) -> 'b t t
                              val iter :
                                'a t ->
                                f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                              val fold :
                                'a t ->
                                init:'-> f:('-> '-> 'b t) -> 'b t
                              val fold_left :
                                'a t ->
                                init:'-> f:('-> '-> 'b t) -> 'b t
                              val fold_right :
                                'a t ->
                                f:('-> '-> 'b t) -> init:'-> 'b t
                              val reduce :
                                'a t -> f:('-> '-> 'a t) -> 'Option.t t
                              val exists : 'a t -> f:('-> bool t) -> bool t
                              val for_all :
                                'a t -> f:('-> bool t) -> bool t
                              val count :
                                'a t -> f:('-> bool t) -> Monoid.Int.t t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'b t -> f:('-> 'a t) -> 'a t
                              val find :
                                'a t -> f:('-> bool t) -> 'Option.t t
                              val find_map :
                                'a t ->
                                f:('-> 'Option.t t) -> 'Option.t t
                              val filter : 'a t -> f:('-> bool t) -> 'a t t
                              val filter_map :
                                'a t -> f:('-> 'Option.t t) -> 'b t t
                            end
                          module Eager :
                            functor (T : Collection.Eager->
                              sig
                                val all : 'a t T.t -> 'T.t t
                                val all_ignore : 'a t T.t -> Monoid.Unit.t t
                                val sequence :
                                  Monoid.Unit.t t T.t -> Monoid.Unit.t t
                                val map :
                                  'T.t -> f:('-> 'b t) -> 'T.t t
                                val iter :
                                  'T.t ->
                                  f:('-> Monoid.Unit.t t) ->
                                  Monoid.Unit.t t
                                val fold :
                                  'T.t ->
                                  init:'-> f:('-> '-> 'b t) -> 'b t
                                val fold_left :
                                  'T.t ->
                                  init:'-> f:('-> '-> 'b t) -> 'b t
                                val fold_right :
                                  'T.t ->
                                  f:('-> '-> 'b t) -> init:'-> 'b t
                                val reduce :
                                  'T.t ->
                                  f:('-> '-> 'a t) -> 'Option.t t
                                val exists :
                                  'T.t -> f:('-> bool t) -> bool t
                                val for_all :
                                  'T.t -> f:('-> bool t) -> bool t
                                val count :
                                  'T.t ->
                                  f:('-> bool t) -> Monoid.Int.t t
                                val map_reduce :
                                  (module Monoid.S with type t = 'a) ->
                                  'T.t -> f:('-> 'a t) -> 'a t
                                val find :
                                  'T.t -> f:('-> bool t) -> 'Option.t t
                                val find_map :
                                  'T.t ->
                                  f:('-> 'Option.t t) -> 'Option.t t
                                val filter :
                                  'T.t -> f:('-> bool t) -> 'T.t t
                                val filter_map :
                                  'T.t ->
                                  f:('-> 'Option.t t) -> 'T.t t
                              end
                          module Delay :
                            functor (T : Collection.Delay->
                              sig
                                val all : 'a t T.t -> 'T.t t
                                val all_ignore : 'a t T.t -> Monoid.Unit.t t
                                val sequence :
                                  Monoid.Unit.t t T.t -> Monoid.Unit.t t
                                val map :
                                  'T.t -> f:('-> 'b t) -> 'T.t t
                                val iter :
                                  'T.t ->
                                  f:('-> Monoid.Unit.t t) ->
                                  Monoid.Unit.t t
                                val fold :
                                  'T.t ->
                                  init:'-> f:('-> '-> 'b t) -> 'b t
                                val fold_left :
                                  'T.t ->
                                  init:'-> f:('-> '-> 'b t) -> 'b t
                                val fold_right :
                                  'T.t ->
                                  f:('-> '-> 'b t) -> init:'-> 'b t
                                val reduce :
                                  'T.t ->
                                  f:('-> '-> 'a t) -> 'Option.t t
                                val exists :
                                  'T.t -> f:('-> bool t) -> bool t
                                val for_all :
                                  'T.t -> f:('-> bool t) -> bool t
                                val count :
                                  'T.t ->
                                  f:('-> bool t) -> Monoid.Int.t t
                                val map_reduce :
                                  (module Monoid.S with type t = 'a) ->
                                  'T.t -> f:('-> 'a t) -> 'a t
                                val find :
                                  'T.t -> f:('-> bool t) -> 'Option.t t
                                val find_map :
                                  'T.t ->
                                  f:('-> 'Option.t t) -> 'Option.t t
                                val filter :
                                  'T.t -> f:('-> bool t) -> 'T.t t
                                val filter_map :
                                  'T.t ->
                                  f:('-> 'Option.t t) -> 'T.t t
                              end
                        end
                      module List :
                        sig
                          val all : 'a t List.t -> 'List.t t
                          val all_ignore : 'a t List.t -> Monoid.Unit.t t
                          val sequence :
                            Monoid.Unit.t t List.t -> Monoid.Unit.t t
                          val map :
                            'List.t -> f:('-> 'b t) -> 'List.t t
                          val iter :
                            'List.t ->
                            f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                          val fold :
                            'List.t ->
                            init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_left :
                            'List.t ->
                            init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_right :
                            'List.t ->
                            f:('-> '-> 'b t) -> init:'-> 'b t
                          val reduce :
                            'List.t ->
                            f:('-> '-> 'a t) -> 'Option.t t
                          val exists :
                            'List.t -> f:('-> bool t) -> bool t
                          val for_all :
                            'List.t -> f:('-> bool t) -> bool t
                          val count :
                            'List.t -> f:('-> bool t) -> Monoid.Int.t t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'List.t -> f:('-> 'a t) -> 'a t
                          val find :
                            'List.t -> f:('-> bool t) -> 'Option.t t
                          val find_map :
                            'List.t ->
                            f:('-> 'Option.t t) -> 'Option.t t
                          val filter :
                            'List.t -> f:('-> bool t) -> 'List.t t
                          val filter_map :
                            'List.t ->
                            f:('-> 'Option.t t) -> 'List.t t
                        end
                      module Seq :
                        sig
                          val all : 'a t Seq.t -> 'Seq.t t
                          val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
                          val sequence :
                            Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
                          val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
                          val iter :
                            'Seq.t ->
                            f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                          val fold :
                            'Seq.t ->
                            init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_left :
                            'Seq.t ->
                            init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_right :
                            'Seq.t ->
                            f:('-> '-> 'b t) -> init:'-> 'b t
                          val reduce :
                            'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
                          val exists : 'Seq.t -> f:('-> bool t) -> bool t
                          val for_all :
                            'Seq.t -> f:('-> bool t) -> bool t
                          val count :
                            'Seq.t -> f:('-> bool t) -> Monoid.Int.t t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'Seq.t -> f:('-> 'a t) -> 'a t
                          val find :
                            'Seq.t -> f:('-> bool t) -> 'Option.t t
                          val find_map :
                            'Seq.t ->
                            f:('-> 'Option.t t) -> 'Option.t t
                          val filter :
                            'Seq.t -> f:('-> bool t) -> 'Seq.t t
                          val filter_map :
                            'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
                        end
                      val ( >=> ) :
                        ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                      val ( !! ) : '-> 'a t
                      val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                      val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      module Monad_infix :
                        sig
                          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                        end
                      val bind : 'a t -> f:('-> 'b t) -> 'b t
                      val return : '-> 'a t
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val join : 'a t t -> 'a t
                      val ignore_m : 'a t -> Monoid.Unit.t t
                      val all : 'a t list -> 'a list t
                      val all_ignore :
                        Monoid.Unit.t t list -> Monoid.Unit.t t
                      module Let_syntax :
                        sig
                          val return : '-> 'a t
                          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                          module Let_syntax :
                            sig
                              val return : '-> 'a t
                              val bind : 'a t -> f:('-> 'b t) -> 'b t
                              val map : 'a t -> f:('-> 'b) -> 'b t
                              val both : 'a t -> 'b t -> ('a * 'b) t
                              module Open_on_rhs : sig  end
                            end
                        end
                      module Syntax :
                        sig
                          val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                          val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                          val ( >=> ) :
                            ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                          val ( !! ) : '-> 'a t
                          val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                          val ( !$$ ) :
                            ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                          val ( !$$$ ) :
                            ('-> '-> '-> 'd) ->
                            'a t -> 'b t -> 'c t -> 'd t
                          val ( !$$$$ ) :
                            ('-> '-> '-> '-> 'e) ->
                            'a t -> 'b t -> 'c t -> 'd t -> 'e t
                          val ( !$$$$$ ) :
                            ('-> '-> '-> '-> '-> 'f) ->
                            'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                        end
                      type env
                      val put : env -> Monoid.Unit.t t
                      val get : Monoid.Unit.t -> env t
                      val gets : (env -> 'r) -> 'r t
                      val update : (env -> env) -> Monoid.Unit.t t
                    end
                  module type S2 =
                    sig
                      type ('a, 'e) t
                      type 'a m
                      type ('a, 'e) e
                      type id
                      module Id :
                        sig
                          type t = id
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          val bin_t : t Bin_prot.Type_class.t
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (Core_kernel__.Import.int -> t)
                            Bin_prot.Read.reader
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_shape_t : Bin_prot.Shape.t
                          val of_string : Monoid.String.t -> t
                          val to_string : t -> Monoid.String.t
                          val ( >= ) : t -> t -> bool
                          val ( <= ) : t -> t -> bool
                          val ( = ) : t -> t -> bool
                          val ( > ) : t -> t -> bool
                          val ( < ) : t -> t -> bool
                          val ( <> ) : t -> t -> bool
                          val equal : t -> t -> bool
                          val compare : t -> t -> Monoid.Int.t
                          val min : t -> t -> t
                          val max : t -> t -> t
                          val ascending : t -> t -> Monoid.Int.t
                          val descending : t -> t -> Monoid.Int.t
                          val between : t -> low:t -> high:t -> bool
                          val clamp_exn : t -> min:t -> max:t -> t
                          val clamp :
                            t -> min:t -> max:t -> t Base__.Or_error.t
                          type comparator_witness
                          val validate_lbound :
                            min:t Base__.Maybe_bound.t ->
                            t Base__.Validate.check
                          val validate_ubound :
                            max:t Base__.Maybe_bound.t ->
                            t Base__.Validate.check
                          val validate_bound :
                            min:t Base__.Maybe_bound.t ->
                            max:t Base__.Maybe_bound.t ->
                            t Base__.Validate.check
                          module Replace_polymorphic_compare :
                            sig
                              val ( >= ) : t -> t -> bool
                              val ( <= ) : t -> t -> bool
                              val ( = ) : t -> t -> bool
                              val ( > ) : t -> t -> bool
                              val ( < ) : t -> t -> bool
                              val ( <> ) : t -> t -> bool
                              val equal : t -> t -> bool
                              val compare : t -> t -> Monoid.Int.t
                              val min : t -> t -> t
                              val max : t -> t -> t
                            end
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                          module Map :
                            sig
                              module Key :
                                sig
                                  type t = id
                                  val t_of_sexp : Sexplib.Sexp.t -> t
                                  val sexp_of_t : t -> Sexplib.Sexp.t
                                  val bin_t : t Bin_prot.Type_class.t
                                  val bin_read_t : t Bin_prot.Read.reader
                                  val __bin_read_t__ :
                                    (Core_kernel__.Import.int -> t)
                                    Bin_prot.Read.reader
                                  val bin_reader_t :
                                    t Bin_prot.Type_class.reader
                                  val bin_size_t : t Bin_prot.Size.sizer
                                  val bin_write_t : t Bin_prot.Write.writer
                                  val bin_writer_t :
                                    t Bin_prot.Type_class.writer
                                  val bin_shape_t : Bin_prot.Shape.t
                                  type comparator_witness =
                                      comparator_witness
                                  val comparator :
                                    (t, comparator_witness)
                                    Core_kernel__.Comparator.comparator
                                end
                              module Tree :
                                sig
                                  type 'a t =
                                      (id, 'a, comparator_witness)
                                      Core_kernel__.Core_map_intf.Tree.t
                                  val empty : 'a t
                                  val singleton : id -> '-> 'a t
                                  val of_alist :
                                    (id * 'a) List.t ->
                                    [ `Duplicate_key of id | `Ok of 'a t ]
                                  val of_alist_or_error :
                                    (id * 'a) List.t ->
                                    'a t Base__.Or_error.t
                                  val of_alist_exn : (id * 'a) List.t -> 'a t
                                  val of_alist_multi :
                                    (id * 'a) List.t -> 'List.t t
                                  val of_alist_fold :
                                    (id * 'a) List.t ->
                                    init:'-> f:('-> '-> 'b) -> 'b t
                                  val of_alist_reduce :
                                    (id * 'a) List.t ->
                                    f:('-> '-> 'a) -> 'a t
                                  val of_sorted_array :
                                    (id * 'a) array -> 'a t Base__.Or_error.t
                                  val of_sorted_array_unchecked :
                                    (id * 'a) array -> 'a t
                                  val of_increasing_iterator_unchecked :
                                    len:Monoid.Int.t ->
                                    f:(Monoid.Int.t -> id * 'a) -> 'a t
                                  val of_iteri :
                                    iteri:(f:(key:id ->
                                              data:'-> Monoid.Unit.t) ->
                                           Monoid.Unit.t) ->
                                    [ `Duplicate_key of id | `Ok of 'v t ]
                                  val of_tree : 'a t -> 'a t
                                  val of_hashtbl_exn :
                                    (id, 'a) Core_kernel__.Core_hashtbl.t ->
                                    'a t
                                  val gen :
                                    id Core_kernel__.Quickcheck.Generator.t ->
                                    'Core_kernel__.Quickcheck.Generator.t ->
                                    'a t Core_kernel__.Quickcheck.Generator.t
                                  val invariants : 'a t -> bool
                                  val is_empty : 'a t -> bool
                                  val length : 'a t -> Monoid.Int.t
                                  val add : 'a t -> key:id -> data:'-> 'a t
                                  val add_multi :
                                    'List.t t ->
                                    key:id -> data:'-> 'List.t t
                                  val remove_multi :
                                    'List.t t -> id -> 'List.t t
                                  val change :
                                    'a t ->
                                    id ->
                                    f:('Option.t -> 'Option.t) -> 'a t
                                  val update :
                                    'a t ->
                                    id -> f:('Option.t -> 'a) -> 'a t
                                  val find : 'a t -> id -> 'Option.t
                                  val find_exn : 'a t -> id -> 'a
                                  val remove : 'a t -> id -> 'a t
                                  val mem : 'a t -> id -> bool
                                  val iter_keys :
                                    'a t ->
                                    f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
                                  val iter :
                                    'a t ->
                                    f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                                  val iteri :
                                    'a t ->
                                    f:(key:id -> data:'-> Monoid.Unit.t) ->
                                    Monoid.Unit.t
                                  val iter2 :
                                    'a t ->
                                    'b t ->
                                    f:(key:id ->
                                       data:[ `Both of 'a * 'b
                                            | `Left of 'a
                                            | `Right of 'b ] ->
                                       Monoid.Unit.t) ->
                                    Monoid.Unit.t
                                  val map : 'a t -> f:('-> 'b) -> 'b t
                                  val mapi :
                                    'a t ->
                                    f:(key:id -> data:'-> 'b) -> 'b t
                                  val fold :
                                    'a t ->
                                    init:'->
                                    f:(key:id -> data:'-> '-> 'b) -> 'b
                                  val fold_right :
                                    'a t ->
                                    init:'->
                                    f:(key:id -> data:'-> '-> 'b) -> 'b
                                  val fold2 :
                                    'a t ->
                                    'b t ->
                                    init:'->
                                    f:(key:id ->
                                       data:[ `Both of 'a * 'b
                                            | `Left of 'a
                                            | `Right of 'b ] ->
                                       '-> 'c) ->
                                    'c
                                  val filter_keys :
                                    'a t -> f:(id -> bool) -> 'a t
                                  val filter : 'a t -> f:('-> bool) -> 'a t
                                  val filteri :
                                    'a t ->
                                    f:(key:id -> data:'-> bool) -> 'a t
                                  val filter_map :
                                    'a t -> f:('-> 'Option.t) -> 'b t
                                  val filter_mapi :
                                    'a t ->
                                    f:(key:id -> data:'-> 'Option.t) ->
                                    'b t
                                  val partition_mapi :
                                    'a t ->
                                    f:(key:id ->
                                       data:'-> [ `Fst of '| `Snd of 'c ]) ->
                                    'b t * 'c t
                                  val partition_map :
                                    'a t ->
                                    f:('-> [ `Fst of '| `Snd of 'c ]) ->
                                    'b t * 'c t
                                  val partitioni_tf :
                                    'a t ->
                                    f:(key:id -> data:'-> bool) ->
                                    'a t * 'a t
                                  val partition_tf :
                                    'a t -> f:('-> bool) -> 'a t * 'a t
                                  val compare_direct :
                                    ('-> '-> Monoid.Int.t) ->
                                    'a t -> 'a t -> Monoid.Int.t
                                  val equal :
                                    ('-> '-> bool) ->
                                    'a t -> 'a t -> bool
                                  val keys : 'a t -> id List.t
                                  val data : 'a t -> 'List.t
                                  val to_alist :
                                    ?key_order:[ `Decreasing | `Increasing ] ->
                                    'a t -> (id * 'a) List.t
                                  val validate :
                                    name:(id -> Monoid.String.t) ->
                                    'Base__.Validate.check ->
                                    'a t Base__.Validate.check
                                  val merge :
                                    'a t ->
                                    'b t ->
                                    f:(key:id ->
                                       [ `Both of 'a * 'b
                                       | `Left of 'a
                                       | `Right of 'b ] -> 'Option.t) ->
                                    'c t
                                  val symmetric_diff :
                                    'a t ->
                                    'a t ->
                                    data_equal:('-> '-> bool) ->
                                    (id, 'a)
                                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                                    Base__.Sequence.t
                                  val min_elt : 'a t -> (id * 'a) Option.t
                                  val min_elt_exn : 'a t -> id * 'a
                                  val max_elt : 'a t -> (id * 'a) Option.t
                                  val max_elt_exn : 'a t -> id * 'a
                                  val for_all :
                                    'a t -> f:('-> bool) -> bool
                                  val for_alli :
                                    'a t ->
                                    f:(key:id -> data:'-> bool) -> bool
                                  val exists : 'a t -> f:('-> bool) -> bool
                                  val existsi :
                                    'a t ->
                                    f:(key:id -> data:'-> bool) -> bool
                                  val count :
                                    'a t -> f:('-> bool) -> Monoid.Int.t
                                  val counti :
                                    'a t ->
                                    f:(key:id -> data:'-> bool) ->
                                    Monoid.Int.t
                                  val split :
                                    'a t ->
                                    id -> 'a t * (id * 'a) Option.t * 'a t
                                  val append :
                                    lower_part:'a t ->
                                    upper_part:'a t ->
                                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                                  val subrange :
                                    'a t ->
                                    lower_bound:id Base__.Maybe_bound.t ->
                                    upper_bound:id Base__.Maybe_bound.t ->
                                    'a t
                                  val fold_range_inclusive :
                                    'a t ->
                                    min:id ->
                                    max:id ->
                                    init:'->
                                    f:(key:id -> data:'-> '-> 'b) -> 'b
                                  val range_to_alist :
                                    'a t ->
                                    min:id -> max:id -> (id * 'a) List.t
                                  val closest_key :
                                    'a t ->
                                    [ `Greater_or_equal_to
                                    | `Greater_than
                                    | `Less_or_equal_to
                                    | `Less_than ] ->
                                    id -> (id * 'a) Option.t
                                  val nth :
                                    'a t ->
                                    Monoid.Int.t -> (id * 'a) Option.t
                                  val nth_exn :
                                    'a t -> Monoid.Int.t -> id * 'a
                                  val rank :
                                    'a t -> id -> Monoid.Int.t Option.t
                                  val to_tree : 'a t -> 'a t
                                  val to_sequence :
                                    ?order:[ `Decreasing_key
                                           | `Increasing_key ] ->
                                    ?keys_greater_or_equal_to:id ->
                                    ?keys_less_or_equal_to:id ->
                                    'a t -> (id * 'a) Base__.Sequence.t
                                  val obs :
                                    id Core_kernel__.Quickcheck.Observer.t ->
                                    'Core_kernel__.Quickcheck.Observer.t ->
                                    'v t Core_kernel__.Quickcheck.Observer.t
                                  val shrinker :
                                    id Core_kernel__.Quickcheck.Shrinker.t ->
                                    'Core_kernel__.Quickcheck.Shrinker.t ->
                                    'v t Core_kernel__.Quickcheck.Shrinker.t
                                  module Provide_of_sexp :
                                    functor
                                      (K : sig
                                             val t_of_sexp :
                                               Sexplib.Sexp.t -> id
                                           end->
                                      sig
                                        val t_of_sexp :
                                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                                          Sexplib.Sexp.t -> 'v_x__017_ t
                                      end
                                  val t_of_sexp :
                                    (Base__.Sexplib.Sexp.t -> 'a) ->
                                    Base__.Sexplib.Sexp.t -> 'a t
                                  val sexp_of_t :
                                    ('-> Base__.Sexplib.Sexp.t) ->
                                    'a t -> Base__.Sexplib.Sexp.t
                                end
                              type 'a t =
                                  (id, 'a, comparator_witness)
                                  Core_kernel__.Core_map_intf.Map.t
                              val compare :
                                ('-> '-> Core_kernel__.Import.int) ->
                                'a t -> 'a t -> Core_kernel__.Import.int
                              val empty : 'a t
                              val singleton : id -> '-> 'a t
                              val of_alist :
                                (id * 'a) List.t ->
                                [ `Duplicate_key of id | `Ok of 'a t ]
                              val of_alist_or_error :
                                (id * 'a) List.t -> 'a t Base__.Or_error.t
                              val of_alist_exn : (id * 'a) List.t -> 'a t
                              val of_alist_multi :
                                (id * 'a) List.t -> 'List.t t
                              val of_alist_fold :
                                (id * 'a) List.t ->
                                init:'-> f:('-> '-> 'b) -> 'b t
                              val of_alist_reduce :
                                (id * 'a) List.t ->
                                f:('-> '-> 'a) -> 'a t
                              val of_sorted_array :
                                (id * 'a) array -> 'a t Base__.Or_error.t
                              val of_sorted_array_unchecked :
                                (id * 'a) array -> 'a t
                              val of_increasing_iterator_unchecked :
                                len:Monoid.Int.t ->
                                f:(Monoid.Int.t -> id * 'a) -> 'a t
                              val of_iteri :
                                iteri:(f:(key:id -> data:'-> Monoid.Unit.t) ->
                                       Monoid.Unit.t) ->
                                [ `Duplicate_key of id | `Ok of 'v t ]
                              val of_tree : 'Tree.t -> 'a t
                              val of_hashtbl_exn :
                                (id, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                              val gen :
                                id Core_kernel__.Quickcheck.Generator.t ->
                                'Core_kernel__.Quickcheck.Generator.t ->
                                'a t Core_kernel__.Quickcheck.Generator.t
                              val invariants : 'a t -> bool
                              val is_empty : 'a t -> bool
                              val length : 'a t -> Monoid.Int.t
                              val add : 'a t -> key:id -> data:'-> 'a t
                              val add_multi :
                                'List.t t ->
                                key:id -> data:'-> 'List.t t
                              val remove_multi :
                                'List.t t -> id -> 'List.t t
                              val change :
                                'a t ->
                                id -> f:('Option.t -> 'Option.t) -> 'a t
                              val update :
                                'a t -> id -> f:('Option.t -> 'a) -> 'a t
                              val find : 'a t -> id -> 'Option.t
                              val find_exn : 'a t -> id -> 'a
                              val remove : 'a t -> id -> 'a t
                              val mem : 'a t -> id -> bool
                              val iter_keys :
                                'a t ->
                                f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
                              val iter :
                                'a t ->
                                f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                              val iteri :
                                'a t ->
                                f:(key:id -> data:'-> Monoid.Unit.t) ->
                                Monoid.Unit.t
                              val iter2 :
                                'a t ->
                                'b t ->
                                f:(key:id ->
                                   data:[ `Both of 'a * 'b
                                        | `Left of 'a
                                        | `Right of 'b ] ->
                                   Monoid.Unit.t) ->
                                Monoid.Unit.t
                              val map : 'a t -> f:('-> 'b) -> 'b t
                              val mapi :
                                'a t -> f:(key:id -> data:'-> 'b) -> 'b t
                              val fold :
                                'a t ->
                                init:'->
                                f:(key:id -> data:'-> '-> 'b) -> 'b
                              val fold_right :
                                'a t ->
                                init:'->
                                f:(key:id -> data:'-> '-> 'b) -> 'b
                              val fold2 :
                                'a t ->
                                'b t ->
                                init:'->
                                f:(key:id ->
                                   data:[ `Both of 'a * 'b
                                        | `Left of 'a
                                        | `Right of 'b ] ->
                                   '-> 'c) ->
                                'c
                              val filter_keys :
                                'a t -> f:(id -> bool) -> 'a t
                              val filter : 'a t -> f:('-> bool) -> 'a t
                              val filteri :
                                'a t -> f:(key:id -> data:'-> bool) -> 'a t
                              val filter_map :
                                'a t -> f:('-> 'Option.t) -> 'b t
                              val filter_mapi :
                                'a t ->
                                f:(key:id -> data:'-> 'Option.t) -> 'b t
                              val partition_mapi :
                                'a t ->
                                f:(key:id ->
                                   data:'-> [ `Fst of '| `Snd of 'c ]) ->
                                'b t * 'c t
                              val partition_map :
                                'a t ->
                                f:('-> [ `Fst of '| `Snd of 'c ]) ->
                                'b t * 'c t
                              val partitioni_tf :
                                'a t ->
                                f:(key:id -> data:'-> bool) -> 'a t * 'a t
                              val partition_tf :
                                'a t -> f:('-> bool) -> 'a t * 'a t
                              val compare_direct :
                                ('-> '-> Monoid.Int.t) ->
                                'a t -> 'a t -> Monoid.Int.t
                              val equal :
                                ('-> '-> bool) -> 'a t -> 'a t -> bool
                              val keys : 'a t -> id List.t
                              val data : 'a t -> 'List.t
                              val to_alist :
                                ?key_order:[ `Decreasing | `Increasing ] ->
                                'a t -> (id * 'a) List.t
                              val validate :
                                name:(id -> Monoid.String.t) ->
                                'Base__.Validate.check ->
                                'a t Base__.Validate.check
                              val merge :
                                'a t ->
                                'b t ->
                                f:(key:id ->
                                   [ `Both of 'a * 'b
                                   | `Left of 'a
                                   | `Right of 'b ] -> 'Option.t) ->
                                'c t
                              val symmetric_diff :
                                'a t ->
                                'a t ->
                                data_equal:('-> '-> bool) ->
                                (id, 'a)
                                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                                Base__.Sequence.t
                              val min_elt : 'a t -> (id * 'a) Option.t
                              val min_elt_exn : 'a t -> id * 'a
                              val max_elt : 'a t -> (id * 'a) Option.t
                              val max_elt_exn : 'a t -> id * 'a
                              val for_all : 'a t -> f:('-> bool) -> bool
                              val for_alli :
                                'a t -> f:(key:id -> data:'-> bool) -> bool
                              val exists : 'a t -> f:('-> bool) -> bool
                              val existsi :
                                'a t -> f:(key:id -> data:'-> bool) -> bool
                              val count :
                                'a t -> f:('-> bool) -> Monoid.Int.t
                              val counti :
                                'a t ->
                                f:(key:id -> data:'-> bool) -> Monoid.Int.t
                              val split :
                                'a t ->
                                id -> 'a t * (id * 'a) Option.t * 'a t
                              val append :
                                lower_part:'a t ->
                                upper_part:'a t ->
                                [ `Ok of 'a t | `Overlapping_key_ranges ]
                              val subrange :
                                'a t ->
                                lower_bound:id Base__.Maybe_bound.t ->
                                upper_bound:id Base__.Maybe_bound.t -> 'a t
                              val fold_range_inclusive :
                                'a t ->
                                min:id ->
                                max:id ->
                                init:'->
                                f:(key:id -> data:'-> '-> 'b) -> 'b
                              val range_to_alist :
                                'a t -> min:id -> max:id -> (id * 'a) List.t
                              val closest_key :
                                'a t ->
                                [ `Greater_or_equal_to
                                | `Greater_than
                                | `Less_or_equal_to
                                | `Less_than ] -> id -> (id * 'a) Option.t
                              val nth :
                                'a t -> Monoid.Int.t -> (id * 'a) Option.t
                              val nth_exn : 'a t -> Monoid.Int.t -> id * 'a
                              val rank : 'a t -> id -> Monoid.Int.t Option.t
                              val to_tree : 'a t -> 'Tree.t
                              val to_sequence :
                                ?order:[ `Decreasing_key | `Increasing_key ] ->
                                ?keys_greater_or_equal_to:id ->
                                ?keys_less_or_equal_to:id ->
                                'a t -> (id * 'a) Base__.Sequence.t
                              val obs :
                                id Core_kernel__.Quickcheck.Observer.t ->
                                'Core_kernel__.Quickcheck.Observer.t ->
                                'v t Core_kernel__.Quickcheck.Observer.t
                              val shrinker :
                                id Core_kernel__.Quickcheck.Shrinker.t ->
                                'Core_kernel__.Quickcheck.Shrinker.t ->
                                'v t Core_kernel__.Quickcheck.Shrinker.t
                              module Provide_of_sexp :
                                functor
                                  (Key : sig
                                           val t_of_sexp :
                                             Sexplib.Sexp.t -> id
                                         end->
                                  sig
                                    val t_of_sexp :
                                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                                      Sexplib.Sexp.t -> 'v_x__018_ t
                                  end
                              module Provide_bin_io :
                                functor
                                  (Key : sig
                                           val bin_t :
                                             id Bin_prot.Type_class.t
                                           val bin_read_t :
                                             id Bin_prot.Read.reader
                                           val __bin_read_t__ :
                                             (Core_kernel__.Import.int -> id)
                                             Bin_prot.Read.reader
                                           val bin_reader_t :
                                             id Bin_prot.Type_class.reader
                                           val bin_size_t :
                                             id Bin_prot.Size.sizer
                                           val bin_write_t :
                                             id Bin_prot.Write.writer
                                           val bin_writer_t :
                                             id Bin_prot.Type_class.writer
                                           val bin_shape_t : Bin_prot.Shape.t
                                         end->
                                  sig
                                    val bin_shape_t :
                                      Bin_prot.Shape.t -> Bin_prot.Shape.t
                                    val bin_size_t :
                                      ('a, 'a t) Bin_prot.Size.sizer1
                                    val bin_write_t :
                                      ('a, 'a t) Bin_prot.Write.writer1
                                    val bin_read_t :
                                      ('a, 'a t) Bin_prot.Read.reader1
                                    val __bin_read_t__ :
                                      ('a, Monoid.Int.t -> 'a t)
                                      Bin_prot.Read.reader1
                                    val bin_writer_t :
                                      ('a, 'a t)
                                      Bin_prot.Type_class.S1.writer
                                    val bin_reader_t :
                                      ('a, 'a t)
                                      Bin_prot.Type_class.S1.reader
                                    val bin_t :
                                      ('a, 'a t) Bin_prot.Type_class.S1.t
                                  end
                              module Provide_hash :
                                functor
                                  (Key : sig
                                           val hash_fold_t :
                                             Base__.Hash.state ->
                                             id -> Base__.Hash.state
                                         end->
                                  sig
                                    val hash_fold_t :
                                      (Ppx_hash_lib.Std.Hash.state ->
                                       '-> Ppx_hash_lib.Std.Hash.state) ->
                                      Ppx_hash_lib.Std.Hash.state ->
                                      'a t -> Ppx_hash_lib.Std.Hash.state
                                  end
                              val t_of_sexp :
                                (Base__.Sexplib.Sexp.t -> 'a) ->
                                Base__.Sexplib.Sexp.t -> 'a t
                              val sexp_of_t :
                                ('-> Base__.Sexplib.Sexp.t) ->
                                'a t -> Base__.Sexplib.Sexp.t
                              val bin_shape_t :
                                Bin_prot.Shape.t -> Bin_prot.Shape.t
                              val bin_size_t :
                                ('a, 'a t) Bin_prot.Size.sizer1
                              val bin_write_t :
                                ('a, 'a t) Bin_prot.Write.writer1
                              val bin_read_t :
                                ('a, 'a t) Bin_prot.Read.reader1
                              val __bin_read_t__ :
                                ('a, Monoid.Int.t -> 'a t)
                                Bin_prot.Read.reader1
                              val bin_writer_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.writer
                              val bin_reader_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.reader
                              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                            end
                          module Set :
                            sig
                              module Elt :
                                sig
                                  type t = id
                                  val bin_t : t Bin_prot.Type_class.t
                                  val bin_read_t : t Bin_prot.Read.reader
                                  val __bin_read_t__ :
                                    (Core_kernel__.Import.int -> t)
                                    Bin_prot.Read.reader
                                  val bin_reader_t :
                                    t Bin_prot.Type_class.reader
                                  val bin_size_t : t Bin_prot.Size.sizer
                                  val bin_write_t : t Bin_prot.Write.writer
                                  val bin_writer_t :
                                    t Bin_prot.Type_class.writer
                                  val bin_shape_t : Bin_prot.Shape.t
                                  val t_of_sexp : Sexplib.Sexp.t -> t
                                  val sexp_of_t : t -> Sexplib.Sexp.t
                                  type comparator_witness =
                                      Map.Key.comparator_witness
                                  val comparator :
                                    (t, comparator_witness)
                                    Core_kernel__.Comparator.comparator
                                end
                              module Tree :
                                sig
                                  type t =
                                      (id, comparator_witness)
                                      Core_kernel__.Core_set_intf.Tree.t
                                  val compare :
                                    t -> t -> Core_kernel__.Import.int
                                  val length : t -> Monoid.Int.t
                                  val is_empty : t -> bool
                                  val iter :
                                    t ->
                                    f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
                                  val fold :
                                    t ->
                                    init:'accum ->
                                    f:('accum -> id -> 'accum) -> 'accum
                                  val fold_result :
                                    t ->
                                    init:'accum ->
                                    f:('accum ->
                                       id -> ('accum, 'e) Base__.Result.t) ->
                                    ('accum, 'e) Base__.Result.t
                                  val exists : t -> f:(id -> bool) -> bool
                                  val for_all : t -> f:(id -> bool) -> bool
                                  val count :
                                    t -> f:(id -> bool) -> Monoid.Int.t
                                  val sum :
                                    (module Base__.Commutative_group.S with type t = 'sum) ->
                                    t -> f:(id -> 'sum) -> 'sum
                                  val find :
                                    t -> f:(id -> bool) -> id Option.t
                                  val find_map :
                                    t -> f:(id -> 'Option.t) -> 'Option.t
                                  val to_list : t -> id List.t
                                  val to_array : t -> id array
                                  val invariants : t -> bool
                                  val mem : t -> id -> bool
                                  val add : t -> id -> t
                                  val remove : t -> id -> t
                                  val union : t -> t -> t
                                  val inter : t -> t -> t
                                  val diff : t -> t -> t
                                  val symmetric_diff :
                                    t ->
                                    t ->
                                    (id, id) Base__.Either.t
                                    Base__.Sequence.t
                                  val compare_direct : t -> t -> Monoid.Int.t
                                  val equal : t -> t -> bool
                                  val is_subset : t -> of_:t -> bool
                                  val subset : t -> t -> bool
                                  val fold_until :
                                    t ->
                                    init:'->
                                    f:('->
                                       id ->
                                       ('b, 'stop)
                                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                                    ('b, 'stop)
                                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                                  val fold_right :
                                    t -> init:'-> f:(id -> '-> 'b) -> 'b
                                  val iter2 :
                                    t ->
                                    t ->
                                    f:([ `Both of id * id
                                       | `Left of id
                                       | `Right of id ] -> Monoid.Unit.t) ->
                                    Monoid.Unit.t
                                  val filter : t -> f:(id -> bool) -> t
                                  val partition_tf :
                                    t -> f:(id -> bool) -> t * t
                                  val elements : t -> id List.t
                                  val min_elt : t -> id Option.t
                                  val min_elt_exn : t -> id
                                  val max_elt : t -> id Option.t
                                  val max_elt_exn : t -> id
                                  val choose : t -> id Option.t
                                  val choose_exn : t -> id
                                  val split : t -> id -> t * id Option.t * t
                                  val group_by :
                                    t -> equiv:(id -> id -> bool) -> t List.t
                                  val find_exn : t -> f:(id -> bool) -> id
                                  val find_index :
                                    t -> Monoid.Int.t -> id Option.t
                                  val nth : t -> Monoid.Int.t -> id Option.t
                                  val remove_index : t -> Monoid.Int.t -> t
                                  val to_tree : t -> t
                                  val to_sequence :
                                    ?order:[ `Decreasing | `Increasing ] ->
                                    ?greater_or_equal_to:id ->
                                    ?less_or_equal_to:id ->
                                    t -> id Base__.Sequence.t
                                  val merge_to_sequence :
                                    ?order:[ `Decreasing | `Increasing ] ->
                                    ?greater_or_equal_to:id ->
                                    ?less_or_equal_to:id ->
                                    t ->
                                    t ->
                                    (id, id)
                                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                                    Base__.Sequence.t
                                  val to_map :
                                    t ->
                                    f:(id -> 'data) ->
                                    (id, 'data, comparator_witness)
                                    Core_kernel__.Core_set_intf.Map.t
                                  val obs :
                                    id Core_kernel__.Quickcheck.Observer.t ->
                                    t Core_kernel__.Quickcheck.Observer.t
                                  val shrinker :
                                    id Core_kernel__.Quickcheck.Shrinker.t ->
                                    t Core_kernel__.Quickcheck.Shrinker.t
                                  val empty : t
                                  val singleton : id -> t
                                  val union_list : t List.t -> t
                                  val of_list : id List.t -> t
                                  val of_array : id array -> t
                                  val of_sorted_array :
                                    id array -> t Base__.Or_error.t
                                  val of_sorted_array_unchecked :
                                    id array -> t
                                  val of_increasing_iterator_unchecked :
                                    len:Monoid.Int.t ->
                                    f:(Monoid.Int.t -> id) -> t
                                  val stable_dedup_list :
                                    id List.t -> id List.t
                                  val map :
                                    ('a, 'b)
                                    Core_kernel__.Core_set_intf.Tree.t ->
                                    f:('-> id) -> t
                                  val filter_map :
                                    ('a, 'b)
                                    Core_kernel__.Core_set_intf.Tree.t ->
                                    f:('-> id Option.t) -> t
                                  val of_tree : t -> t
                                  val of_hash_set :
                                    id Core_kernel__.Hash_set.t -> t
                                  val of_hashtbl_keys :
                                    (id, 'a) Core_kernel__.Core_hashtbl.t ->
                                    t
                                  val of_map_keys :
                                    (id, 'a, comparator_witness)
                                    Core_kernel__.Core_set_intf.Map.t -> 
                                    t
                                  val gen :
                                    id Core_kernel__.Quickcheck.Generator.t ->
                                    t Core_kernel__.Quickcheck.Generator.t
                                  module Provide_of_sexp :
                                    functor
                                      (Elt : sig
                                               val t_of_sexp :
                                                 Sexplib.Sexp.t -> id
                                             end->
                                      sig
                                        val t_of_sexp : Sexplib.Sexp.t -> t
                                      end
                                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                                end
                              type t = (id, comparator_witness) Base.Set.t
                              val compare :
                                t -> t -> Core_kernel__.Import.int
                              val length : t -> Monoid.Int.t
                              val is_empty : t -> bool
                              val iter :
                                t -> f:(id -> Monoid.Unit.t) -> Monoid.Unit.t
                              val fold :
                                t ->
                                init:'accum ->
                                f:('accum -> id -> 'accum) -> 'accum
                              val fold_result :
                                t ->
                                init:'accum ->
                                f:('accum ->
                                   id -> ('accum, 'e) Base__.Result.t) ->
                                ('accum, 'e) Base__.Result.t
                              val exists : t -> f:(id -> bool) -> bool
                              val for_all : t -> f:(id -> bool) -> bool
                              val count : t -> f:(id -> bool) -> Monoid.Int.t
                              val sum :
                                (module Base__.Commutative_group.S with type t = 'sum) ->
                                t -> f:(id -> 'sum) -> 'sum
                              val find : t -> f:(id -> bool) -> id Option.t
                              val find_map :
                                t -> f:(id -> 'Option.t) -> 'Option.t
                              val to_list : t -> id List.t
                              val to_array : t -> id array
                              val invariants : t -> bool
                              val mem : t -> id -> bool
                              val add : t -> id -> t
                              val remove : t -> id -> t
                              val union : t -> t -> t
                              val inter : t -> t -> t
                              val diff : t -> t -> t
                              val symmetric_diff :
                                t ->
                                t ->
                                (id, id) Base__.Either.t Base__.Sequence.t
                              val compare_direct : t -> t -> Monoid.Int.t
                              val equal : t -> t -> bool
                              val is_subset : t -> of_:t -> bool
                              val subset : t -> t -> bool
                              val fold_until :
                                t ->
                                init:'->
                                f:('->
                                   id ->
                                   ('b, 'stop)
                                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                                ('b, 'stop)
                                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                              val fold_right :
                                t -> init:'-> f:(id -> '-> 'b) -> 'b
                              val iter2 :
                                t ->
                                t ->
                                f:([ `Both of id * id
                                   | `Left of id
                                   | `Right of id ] -> Monoid.Unit.t) ->
                                Monoid.Unit.t
                              val filter : t -> f:(id -> bool) -> t
                              val partition_tf : t -> f:(id -> bool) -> t * t
                              val elements : t -> id List.t
                              val min_elt : t -> id Option.t
                              val min_elt_exn : t -> id
                              val max_elt : t -> id Option.t
                              val max_elt_exn : t -> id
                              val choose : t -> id Option.t
                              val choose_exn : t -> id
                              val split : t -> id -> t * id Option.t * t
                              val group_by :
                                t -> equiv:(id -> id -> bool) -> t List.t
                              val find_exn : t -> f:(id -> bool) -> id
                              val find_index :
                                t -> Monoid.Int.t -> id Option.t
                              val nth : t -> Monoid.Int.t -> id Option.t
                              val remove_index : t -> Monoid.Int.t -> t
                              val to_tree : t -> Tree.t
                              val to_sequence :
                                ?order:[ `Decreasing | `Increasing ] ->
                                ?greater_or_equal_to:id ->
                                ?less_or_equal_to:id ->
                                t -> id Base__.Sequence.t
                              val merge_to_sequence :
                                ?order:[ `Decreasing | `Increasing ] ->
                                ?greater_or_equal_to:id ->
                                ?less_or_equal_to:id ->
                                t ->
                                t ->
                                (id, id)
                                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                                Base__.Sequence.t
                              val to_map :
                                t ->
                                f:(id -> 'data) ->
                                (id, 'data, comparator_witness)
                                Core_kernel__.Core_set_intf.Map.t
                              val obs :
                                id Core_kernel__.Quickcheck.Observer.t ->
                                t Core_kernel__.Quickcheck.Observer.t
                              val shrinker :
                                id Core_kernel__.Quickcheck.Shrinker.t ->
                                t Core_kernel__.Quickcheck.Shrinker.t
                              val empty : t
                              val singleton : id -> t
                              val union_list : t List.t -> t
                              val of_list : id List.t -> t
                              val of_array : id array -> t
                              val of_sorted_array :
                                id array -> t Base__.Or_error.t
                              val of_sorted_array_unchecked : id array -> t
                              val of_increasing_iterator_unchecked :
                                len:Monoid.Int.t ->
                                f:(Monoid.Int.t -> id) -> t
                              val stable_dedup_list : id List.t -> id List.t
                              val map :
                                ('a, 'b) Base.Set.t -> f:('-> id) -> t
                              val filter_map :
                                ('a, 'b) Base.Set.t ->
                                f:('-> id Option.t) -> t
                              val of_tree : Tree.t -> t
                              val of_hash_set :
                                id Core_kernel__.Hash_set.t -> t
                              val of_hashtbl_keys :
                                (id, 'a) Core_kernel__.Core_hashtbl.t -> t
                              val of_map_keys :
                                (id, 'a, comparator_witness)
                                Core_kernel__.Core_set_intf.Map.t -> 
                                t
                              val gen :
                                id Core_kernel__.Quickcheck.Generator.t ->
                                t Core_kernel__.Quickcheck.Generator.t
                              module Provide_of_sexp :
                                functor
                                  (Elt : sig
                                           val t_of_sexp :
                                             Sexplib.Sexp.t -> id
                                         end->
                                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
                              module Provide_bin_io :
                                functor
                                  (Elt : sig
                                           val bin_t :
                                             id Bin_prot.Type_class.t
                                           val bin_read_t :
                                             id Bin_prot.Read.reader
                                           val __bin_read_t__ :
                                             (Core_kernel__.Import.int -> id)
                                             Bin_prot.Read.reader
                                           val bin_reader_t :
                                             id Bin_prot.Type_class.reader
                                           val bin_size_t :
                                             id Bin_prot.Size.sizer
                                           val bin_write_t :
                                             id Bin_prot.Write.writer
                                           val bin_writer_t :
                                             id Bin_prot.Type_class.writer
                                           val bin_shape_t : Bin_prot.Shape.t
                                         end->
                                  sig
                                    val bin_size_t : t Bin_prot.Size.sizer
                                    val bin_write_t : t Bin_prot.Write.writer
                                    val bin_read_t : t Bin_prot.Read.reader
                                    val __bin_read_t__ :
                                      (Monoid.Int.t -> t)
                                      Bin_prot.Read.reader
                                    val bin_shape_t : Bin_prot.Shape.t
                                    val bin_writer_t :
                                      t Bin_prot.Type_class.writer
                                    val bin_reader_t :
                                      t Bin_prot.Type_class.reader
                                    val bin_t : t Bin_prot.Type_class.t
                                  end
                              module Provide_hash :
                                functor
                                  (Elt : sig
                                           val hash_fold_t :
                                             Base__.Hash.state ->
                                             id -> Base__.Hash.state
                                         end->
                                  sig
                                    val hash_fold_t :
                                      Ppx_hash_lib.Std.Hash.state ->
                                      t -> Ppx_hash_lib.Std.Hash.state
                                    val hash :
                                      t -> Ppx_hash_lib.Std.Hash.hash_value
                                  end
                              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (Monoid.Int.t -> t) Bin_prot.Read.reader
                              val bin_shape_t : Bin_prot.Shape.t
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_t : t Bin_prot.Type_class.t
                            end
                          val hash : t -> Core_kernel__.Import.int
                          val hashable :
                            t Core_kernel__.Hashable.Hashtbl.Hashable.t
                          module Table :
                            sig
                              type key = t
                              type ('a, 'b) hashtbl =
                                  ('a, 'b) Id.Table.hashtbl
                              type 'b t = (key, 'b) hashtbl
                              val sexp_of_t :
                                ('-> Sexplib.Sexp.t) ->
                                'b t -> Sexplib.Sexp.t
                              type ('a, 'b) t_ = 'b t
                              type 'a key_ = key
                              val hashable :
                                key
                                Core_kernel__.Core_hashtbl_intf.Hashable.t
                              val invariant :
                                'Base__.Invariant_intf.inv ->
                                'a t Base__.Invariant_intf.inv
                              val create :
                                (key, 'b, Monoid.Unit.t -> 'b t)
                                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                              val of_alist :
                                (key, 'b,
                                 (key * 'b) List.t ->
                                 [ `Duplicate_key of key | `Ok of 'b t ])
                                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                              val of_alist_report_all_dups :
                                (key, 'b,
                                 (key * 'b) List.t ->
                                 [ `Duplicate_keys of key List.t
                                 | `Ok of 'b t ])
                                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                              val of_alist_or_error :
                                (key, 'b,
                                 (key * 'b) List.t -> 'b t Base__.Or_error.t)
                                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                              val of_alist_exn :
                                (key, 'b, (key * 'b) List.t -> 'b t)
                                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                              val of_alist_multi :
                                (key, 'List.t,
                                 (key * 'b) List.t -> 'List.t t)
                                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                              val create_mapped :
                                (key, 'b,
                                 get_key:('-> key) ->
                                 get_data:('-> 'b) ->
                                 'List.t ->
                                 [ `Duplicate_keys of key List.t
                                 | `Ok of 'b t ])
                                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                              val create_with_key :
                                (key, 'r,
                                 get_key:('-> key) ->
                                 'List.t ->
                                 [ `Duplicate_keys of key List.t
                                 | `Ok of 'r t ])
                                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                              val create_with_key_or_error :
                                (key, 'r,
                                 get_key:('-> key) ->
                                 'List.t -> 'r t Base__.Or_error.t)
                                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                              val create_with_key_exn :
                                (key, 'r,
                                 get_key:('-> key) -> 'List.t -> 'r t)
                                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                              val group :
                                (key, 'b,
                                 get_key:('-> key) ->
                                 get_data:('-> 'b) ->
                                 combine:('-> '-> 'b) ->
                                 'List.t -> 'b t)
                                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                              val clear : 'a t -> Monoid.Unit.t
                              val copy : 'b t -> 'b t
                              val fold :
                                'b t ->
                                init:'->
                                f:(key:key -> data:'-> '-> 'c) -> 'c
                              val iter_keys :
                                'a t ->
                                f:(key -> Monoid.Unit.t) -> Monoid.Unit.t
                              val iter :
                                'b t ->
                                f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                              val iteri :
                                'b t ->
                                f:(key:key -> data:'-> Monoid.Unit.t) ->
                                Monoid.Unit.t
                              val iter_vals :
                                'b t ->
                                f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                              val existsi :
                                'b t ->
                                f:(key:key -> data:'-> bool) -> bool
                              val exists : 'b t -> f:('-> bool) -> bool
                              val for_alli :
                                'b t ->
                                f:(key:key -> data:'-> bool) -> bool
                              val for_all : 'b t -> f:('-> bool) -> bool
                              val counti :
                                'b t ->
                                f:(key:key -> data:'-> bool) ->
                                Monoid.Int.t
                              val count :
                                'b t -> f:('-> bool) -> Monoid.Int.t
                              val length : 'a t -> Monoid.Int.t
                              val is_empty : 'a t -> bool
                              val mem : 'a t -> key -> bool
                              val remove : 'a t -> key -> Monoid.Unit.t
                              val replace :
                                'b t -> key:key -> data:'-> Monoid.Unit.t
                              val set :
                                'b t -> key:key -> data:'-> Monoid.Unit.t
                              val add :
                                'b t ->
                                key:key -> data:'-> [ `Duplicate | `Ok ]
                              val add_or_error :
                                'b t ->
                                key:key ->
                                data:'-> Monoid.Unit.t Base__.Or_error.t
                              val add_exn :
                                'b t -> key:key -> data:'-> Monoid.Unit.t
                              val change :
                                'b t ->
                                key ->
                                f:('Option.t -> 'Option.t) ->
                                Monoid.Unit.t
                              val update :
                                'b t ->
                                key -> f:('Option.t -> 'b) -> Monoid.Unit.t
                              val add_multi :
                                'List.t t ->
                                key:key -> data:'-> Monoid.Unit.t
                              val remove_multi :
                                'List.t t -> key -> Monoid.Unit.t
                              val map : 'b t -> f:('-> 'c) -> 'c t
                              val mapi :
                                'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                              val filter_map :
                                'b t -> f:('-> 'Option.t) -> 'c t
                              val filter_mapi :
                                'b t ->
                                f:(key:key -> data:'-> 'Option.t) -> 'c t
                              val filter_keys :
                                'b t -> f:(key -> bool) -> 'b t
                              val filter : 'b t -> f:('-> bool) -> 'b t
                              val filteri :
                                'b t ->
                                f:(key:key -> data:'-> bool) -> 'b t
                              val partition_map :
                                'b t ->
                                f:('-> [ `Fst of '| `Snd of 'd ]) ->
                                'c t * 'd t
                              val partition_mapi :
                                'b t ->
                                f:(key:key ->
                                   data:'-> [ `Fst of '| `Snd of 'd ]) ->
                                'c t * 'd t
                              val partition_tf :
                                'b t -> f:('-> bool) -> 'b t * 'b t
                              val partitioni_tf :
                                'b t ->
                                f:(key:key -> data:'-> bool) -> 'b t * 'b t
                              val find_or_add :
                                'b t ->
                                key -> default:(Monoid.Unit.t -> 'b) -> 'b
                              val find : 'b t -> key -> 'Option.t
                              val find_exn : 'b t -> key -> 'b
                              val find_and_call :
                                'b t ->
                                key ->
                                if_found:('-> 'c) ->
                                if_not_found:(key -> 'c) -> 'c
                              val find_and_remove :
                                'b t -> key -> 'Option.t
                              val merge :
                                'a t ->
                                'b t ->
                                f:(key:key ->
                                   [ `Both of 'a * 'b
                                   | `Left of 'a
                                   | `Right of 'b ] -> 'Option.t) ->
                                'c t
                              type 'a merge_into_action =
                                  Remove
                                | Set_to of 'a
                              val merge_into :
                                src:'a t ->
                                dst:'b t ->
                                f:(key:key ->
                                   '-> 'Option.t -> 'b merge_into_action) ->
                                Monoid.Unit.t
                              val keys : 'a t -> key List.t
                              val data : 'b t -> 'List.t
                              val filter_keys_inplace :
                                'a t -> f:(key -> bool) -> Monoid.Unit.t
                              val filter_inplace :
                                'b t -> f:('-> bool) -> Monoid.Unit.t
                              val filteri_inplace :
                                'b t ->
                                f:(key:key -> data:'-> bool) ->
                                Monoid.Unit.t
                              val map_inplace :
                                'b t -> f:('-> 'b) -> Monoid.Unit.t
                              val mapi_inplace :
                                'b t ->
                                f:(key:key -> data:'-> 'b) -> Monoid.Unit.t
                              val filter_map_inplace :
                                'b t ->
                                f:('-> 'Option.t) -> Monoid.Unit.t
                              val filter_mapi_inplace :
                                'b t ->
                                f:(key:key -> data:'-> 'Option.t) ->
                                Monoid.Unit.t
                              val replace_all :
                                'b t -> f:('-> 'b) -> Monoid.Unit.t
                              val replace_alli :
                                'b t ->
                                f:(key:key -> data:'-> 'b) -> Monoid.Unit.t
                              val filter_replace_all :
                                'b t ->
                                f:('-> 'Option.t) -> Monoid.Unit.t
                              val filter_replace_alli :
                                'b t ->
                                f:(key:key -> data:'-> 'Option.t) ->
                                Monoid.Unit.t
                              val equal :
                                'b t -> 'b t -> ('-> '-> bool) -> bool
                              val similar :
                                'b1 t ->
                                'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                              val to_alist : 'b t -> (key * 'b) List.t
                              val validate :
                                name:(key -> Monoid.String.t) ->
                                'Base__.Validate.check ->
                                'b t Base__.Validate.check
                              val incr :
                                ?by:Monoid.Int.t ->
                                ?remove_if_zero:bool ->
                                Monoid.Int.t t -> key -> Monoid.Unit.t
                              val decr :
                                ?by:Monoid.Int.t ->
                                ?remove_if_zero:bool ->
                                Monoid.Int.t t -> key -> Monoid.Unit.t
                              module Provide_of_sexp :
                                functor
                                  (Key : sig
                                           val t_of_sexp :
                                             Sexplib.Sexp.t -> key
                                         end->
                                  sig
                                    val t_of_sexp :
                                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                                      Sexplib.Sexp.t -> 'v_x__001_ t
                                  end
                              module Provide_bin_io :
                                functor
                                  (Key : sig
                                           val bin_t :
                                             key Bin_prot.Type_class.t
                                           val bin_read_t :
                                             key Bin_prot.Read.reader
                                           val __bin_read_t__ :
                                             (Core_kernel__.Import.int -> key)
                                             Bin_prot.Read.reader
                                           val bin_reader_t :
                                             key Bin_prot.Type_class.reader
                                           val bin_size_t :
                                             key Bin_prot.Size.sizer
                                           val bin_write_t :
                                             key Bin_prot.Write.writer
                                           val bin_writer_t :
                                             key Bin_prot.Type_class.writer
                                           val bin_shape_t : Bin_prot.Shape.t
                                         end->
                                  sig
                                    val bin_t :
                                      'Bin_prot.Type_class.t ->
                                      'a t Bin_prot.Type_class.t
                                    val bin_read_t :
                                      'Bin_prot.Read.reader ->
                                      'a t Bin_prot.Read.reader
                                    val __bin_read_t__ :
                                      'Bin_prot.Read.reader ->
                                      (Core_kernel__.Import.int -> 'a t)
                                      Bin_prot.Read.reader
                                    val bin_reader_t :
                                      'Bin_prot.Type_class.reader ->
                                      'a t Bin_prot.Type_class.reader
                                    val bin_size_t :
                                      'Bin_prot.Size.sizer ->
                                      'a t Bin_prot.Size.sizer
                                    val bin_write_t :
                                      'Bin_prot.Write.writer ->
                                      'a t Bin_prot.Write.writer
                                    val bin_writer_t :
                                      'Bin_prot.Type_class.writer ->
                                      'a t Bin_prot.Type_class.writer
                                    val bin_shape_t :
                                      Bin_prot.Shape.t -> Bin_prot.Shape.t
                                  end
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__002_) ->
                                Sexplib.Sexp.t -> 'v_x__002_ t
                              val bin_shape_t :
                                Bin_prot.Shape.t -> Bin_prot.Shape.t
                              val bin_size_t :
                                ('a, 'a t) Bin_prot.Size.sizer1
                              val bin_write_t :
                                ('a, 'a t) Bin_prot.Write.writer1
                              val bin_read_t :
                                ('a, 'a t) Bin_prot.Read.reader1
                              val __bin_read_t__ :
                                ('a, Monoid.Int.t -> 'a t)
                                Bin_prot.Read.reader1
                              val bin_writer_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.writer
                              val bin_reader_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.reader
                              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                            end
                          module Hash_set :
                            sig
                              type elt = t
                              type t = elt Core_kernel__.Hash_set.t
                              val sexp_of_t : t -> Sexplib.Sexp.t
                              type 'a t_ = t
                              type 'a elt_ = elt
                              val create :
                                ('a, Monoid.Unit.t -> t)
                                Core_kernel__.Hash_set_intf.create_options_without_hashable
                              val of_list :
                                ('a, elt List.t -> t)
                                Core_kernel__.Hash_set_intf.create_options_without_hashable
                              module Provide_of_sexp :
                                functor
                                  (X : sig
                                         val t_of_sexp :
                                           Sexplib.Sexp.t -> elt
                                       end->
                                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
                              module Provide_bin_io :
                                functor
                                  (X : sig
                                         val bin_t :
                                           elt Bin_prot.Type_class.t
                                         val bin_read_t :
                                           elt Bin_prot.Read.reader
                                         val __bin_read_t__ :
                                           (Core_kernel__.Import.int -> elt)
                                           Bin_prot.Read.reader
                                         val bin_reader_t :
                                           elt Bin_prot.Type_class.reader
                                         val bin_size_t :
                                           elt Bin_prot.Size.sizer
                                         val bin_write_t :
                                           elt Bin_prot.Write.writer
                                         val bin_writer_t :
                                           elt Bin_prot.Type_class.writer
                                         val bin_shape_t : Bin_prot.Shape.t
                                       end->
                                  sig
                                    val bin_t : t Bin_prot.Type_class.t
                                    val bin_read_t : t Bin_prot.Read.reader
                                    val __bin_read_t__ :
                                      (Core_kernel__.Import.int -> t)
                                      Bin_prot.Read.reader
                                    val bin_reader_t :
                                      t Bin_prot.Type_class.reader
                                    val bin_size_t : t Bin_prot.Size.sizer
                                    val bin_write_t : t Bin_prot.Write.writer
                                    val bin_writer_t :
                                      t Bin_prot.Type_class.writer
                                    val bin_shape_t : Bin_prot.Shape.t
                                  end
                              val t_of_sexp : Sexplib.Sexp.t -> t
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (Monoid.Int.t -> t) Bin_prot.Read.reader
                              val bin_shape_t : Bin_prot.Shape.t
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_t : t Bin_prot.Type_class.t
                            end
                          module Hash_queue :
                            sig
                              module Key :
                                sig
                                  type t = id
                                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                                  val compare : t -> t -> Monoid.Int.t
                                  val hash : t -> Monoid.Int.t
                                end
                              type 'a t
                              val sexp_of_t :
                                ('-> Sexplib.Sexp.t) ->
                                'a t -> Sexplib.Sexp.t
                              val length : 'a t -> Monoid.Int.t
                              val is_empty : 'a t -> bool
                              val iter :
                                'a t ->
                                f:('-> Monoid.Unit.t) -> Monoid.Unit.t
                              val fold :
                                'a t ->
                                init:'accum ->
                                f:('accum -> '-> 'accum) -> 'accum
                              val fold_result :
                                'a t ->
                                init:'accum ->
                                f:('accum ->
                                   '-> ('accum, 'e) Base__.Result.t) ->
                                ('accum, 'e) Base__.Result.t
                              val fold_until :
                                'a t ->
                                init:'accum ->
                                f:('accum ->
                                   '->
                                   ('accum, 'stop)
                                   Base.Container_intf.Continue_or_stop.t) ->
                                ('accum, 'stop)
                                Base.Container_intf.Finished_or_stopped_early.t
                              val exists : 'a t -> f:('-> bool) -> bool
                              val for_all : 'a t -> f:('-> bool) -> bool
                              val count :
                                'a t -> f:('-> bool) -> Monoid.Int.t
                              val sum :
                                (module Base__.Commutative_group.S with type t = 'sum) ->
                                'a t -> f:('-> 'sum) -> 'sum
                              val find :
                                'a t -> f:('-> bool) -> 'Option.t
                              val find_map :
                                'a t -> f:('-> 'Option.t) -> 'Option.t
                              val to_list : 'a t -> 'List.t
                              val to_array : 'a t -> 'a array
                              val min_elt :
                                'a t ->
                                cmp:('-> '-> Monoid.Int.t) -> 'Option.t
                              val max_elt :
                                'a t ->
                                cmp:('-> '-> Monoid.Int.t) -> 'Option.t
                              val invariant :
                                'a t -> Core_kernel__.Import.unit
                              val create :
                                ?growth_allowed:Core_kernel__.Import.bool ->
                                ?size:Core_kernel__.Import.int ->
                                Core_kernel__.Import.unit -> 'a t
                              val clear : 'a t -> Core_kernel__.Import.unit
                              val mem :
                                'a t -> id -> Core_kernel__.Import.bool
                              val lookup :
                                'a t -> id -> 'Core_kernel__.Import.option
                              val lookup_exn : 'a t -> id -> 'a
                              val enqueue :
                                'a t ->
                                id -> '-> [ `Key_already_present | `Ok ]
                              val enqueue_exn :
                                'a t -> id -> '-> Core_kernel__.Import.unit
                              val lookup_and_move_to_back :
                                'a t -> id -> 'Core_kernel__.Import.option
                              val lookup_and_move_to_back_exn :
                                'a t -> id -> 'a
                              val first :
                                'a t -> 'Core_kernel__.Import.option
                              val first_with_key :
                                'a t -> (id * 'a) Core_kernel__.Import.option
                              val keys : 'a t -> id Core_kernel__.Import.list
                              val dequeue :
                                'a t -> 'Core_kernel__.Import.option
                              val dequeue_exn : 'a t -> 'a
                              val dequeue_with_key :
                                'a t -> (id * 'a) Core_kernel__.Import.option
                              val dequeue_with_key_exn : 'a t -> id * 'a
                              val dequeue_all :
                                'a t ->
                                f:('-> Core_kernel__.Import.unit) ->
                                Core_kernel__.Import.unit
                              val remove :
                                'a t -> id -> [ `No_such_key | `Ok ]
                              val remove_exn :
                                'a t -> id -> Core_kernel__.Import.unit
                              val replace :
                                'a t -> id -> '-> [ `No_such_key | `Ok ]
                              val replace_exn :
                                'a t -> id -> '-> Core_kernel__.Import.unit
                              val iteri :
                                'a t ->
                                f:(key:id ->
                                   data:'-> Core_kernel__.Import.unit) ->
                                Core_kernel__.Import.unit
                              val foldi :
                                'a t ->
                                init:'->
                                f:('-> key:id -> data:'-> 'b) -> 'b
                            end
                          val pp :
                            Base__.Import.Caml.Format.formatter ->
                            t -> Monoid.Unit.t
                        end
                      val global : Monads.Std.Monad.State.Multi.S2.id
                      val fork : unit -> (unit, 'e) t
                      val switch :
                        Monads.Std.Monad.State.Multi.S2.id -> (unit, 'e) t
                      val parent :
                        unit -> (Monads.Std.Monad.State.Multi.S2.id, 'e) t
                      val ancestor :
                        Monads.Std.Monad.State.Multi.S2.id list ->
                        (Monads.Std.Monad.State.Multi.S2.id, 'e) t
                      val current :
                        unit -> (Monads.Std.Monad.State.Multi.S2.id, 'e) t
                      val kill :
                        Monads.Std.Monad.State.Multi.S2.id -> (unit, 'e) t
                      val forks :
                        unit ->
                        (Monads.Std.Monad.State.Multi.S2.id
                         Core_kernel.Std.Sequence.t, 'e)
                        t
                      val status :
                        Monads.Std.Monad.State.Multi.S2.id ->
                        (Monads.Std.Monad.State.Multi.status, 'e) t
                      val lift : 'a m -> ('a, 'e) t
                      val run : ('a, 'e) t -> ('a, 'e) e
                      val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                      val forever : ('a, 'e) t -> ('b, 'e) t
                      module Fn :
                        sig
                          val id : '-> ('a, 'e) t
                          val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                          val nothing :
                            Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                          val non :
                            ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                          val apply_n_times :
                            n:Monoid.Int.t ->
                            ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                          val compose :
                            ('-> ('c, 'e) t) ->
                            ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                        end
                      module Pair :
                        sig
                          val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                          val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                        end
                      module Triple :
                        sig
                          val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                          val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                          val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                        end
                      module Lift :
                        sig
                          val nullary : '-> ('a, 'e) t
                          val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                          val binary :
                            ('-> '-> 'c) ->
                            ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                          val ternary :
                            ('-> '-> '-> 'd) ->
                            ('a, 'e) t ->
                            ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                          val quaternary :
                            ('-> '-> '-> '-> 'e) ->
                            ('a, 's) t ->
                            ('b, 's) t ->
                            ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                          val quinary :
                            ('-> '-> '-> '-> '-> 'f) ->
                            ('a, 's) t ->
                            ('b, 's) t ->
                            ('c, 's) t ->
                            ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                        end
                      module Exn :
                        sig
                          val expect :
                            ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                            f:(Monoid.Unit.t -> ('a, 's) t) ->
                            catch:(exn -> ('a, 's) t) -> ('a, 's) t
                        end
                      module Collection :
                        sig
                          module type S =
                            sig
                              type 'a t
                              val all : ('a, 'e) t t -> ('a t, 'e) t
                              val all_ignore :
                                ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
                              val sequence :
                                (Monoid.Unit.t, 'e) t t ->
                                (Monoid.Unit.t, 'e) t
                              val map :
                                'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                              val iter :
                                'a t ->
                                f:('-> (Monoid.Unit.t, 'e) t) ->
                                (Monoid.Unit.t, 'e) t
                              val fold :
                                'a t ->
                                init:'->
                                f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                              val fold_left :
                                'a t ->
                                init:'->
                                f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                              val fold_right :
                                'a t ->
                                f:('-> '-> ('b, 'e) t) ->
                                init:'-> ('b, 'e) t
                              val reduce :
                                'a t ->
                                f:('-> '-> ('a, 'e) t) ->
                                ('Option.t, 'e) t
                              val exists :
                                'a t ->
                                f:('-> (bool, 'e) t) -> (bool, 'e) t
                              val for_all :
                                'a t ->
                                f:('-> (bool, 'e) t) -> (bool, 'e) t
                              val count :
                                'a t ->
                                f:('-> (bool, 'e) t) ->
                                (Monoid.Int.t, 'e) t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                              val find :
                                'a t ->
                                f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                              val find_map :
                                'a t ->
                                f:('-> ('Option.t, 'e) t) ->
                                ('Option.t, 'e) t
                              val filter :
                                'a t ->
                                f:('-> (bool, 'e) t) -> ('a t, 'e) t
                              val filter_map :
                                'a t ->
                                f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                            end
                          module Eager :
                            functor (T : Collection.Eager->
                              sig
                                val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                                val all_ignore :
                                  ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                                val sequence :
                                  (Monoid.Unit.t, 'e) t T.t ->
                                  (Monoid.Unit.t, 'e) t
                                val map :
                                  'T.t ->
                                  f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                                val iter :
                                  'T.t ->
                                  f:('-> (Monoid.Unit.t, 'e) t) ->
                                  (Monoid.Unit.t, 'e) t
                                val fold :
                                  'T.t ->
                                  init:'->
                                  f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                                val fold_left :
                                  'T.t ->
                                  init:'->
                                  f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                                val fold_right :
                                  'T.t ->
                                  f:('-> '-> ('b, 'e) t) ->
                                  init:'-> ('b, 'e) t
                                val reduce :
                                  'T.t ->
                                  f:('-> '-> ('a, 'e) t) ->
                                  ('Option.t, 'e) t
                                val exists :
                                  'T.t ->
                                  f:('-> (bool, 'e) t) -> (bool, 'e) t
                                val for_all :
                                  'T.t ->
                                  f:('-> (bool, 'e) t) -> (bool, 'e) t
                                val count :
                                  'T.t ->
                                  f:('-> (bool, 'e) t) ->
                                  (Monoid.Int.t, 'e) t
                                val map_reduce :
                                  (module Monoid.S with type t = 'a) ->
                                  'T.t ->
                                  f:('-> ('a, 'e) t) -> ('a, 'e) t
                                val find :
                                  'T.t ->
                                  f:('-> (bool, 'e) t) ->
                                  ('Option.t, 'e) t
                                val find_map :
                                  'T.t ->
                                  f:('-> ('Option.t, 'e) t) ->
                                  ('Option.t, 'e) t
                                val filter :
                                  'T.t ->
                                  f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                                val filter_map :
                                  'T.t ->
                                  f:('-> ('Option.t, 'e) t) ->
                                  ('T.t, 'e) t
                              end
                          module Delay :
                            functor (T : Collection.Delay->
                              sig
                                val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                                val all_ignore :
                                  ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                                val sequence :
                                  (Monoid.Unit.t, 'e) t T.t ->
                                  (Monoid.Unit.t, 'e) t
                                val map :
                                  'T.t ->
                                  f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                                val iter :
                                  'T.t ->
                                  f:('-> (Monoid.Unit.t, 'e) t) ->
                                  (Monoid.Unit.t, 'e) t
                                val fold :
                                  'T.t ->
                                  init:'->
                                  f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                                val fold_left :
                                  'T.t ->
                                  init:'->
                                  f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                                val fold_right :
                                  'T.t ->
                                  f:('-> '-> ('b, 'e) t) ->
                                  init:'-> ('b, 'e) t
                                val reduce :
                                  'T.t ->
                                  f:('-> '-> ('a, 'e) t) ->
                                  ('Option.t, 'e) t
                                val exists :
                                  'T.t ->
                                  f:('-> (bool, 'e) t) -> (bool, 'e) t
                                val for_all :
                                  'T.t ->
                                  f:('-> (bool, 'e) t) -> (bool, 'e) t
                                val count :
                                  'T.t ->
                                  f:('-> (bool, 'e) t) ->
                                  (Monoid.Int.t, 'e) t
                                val map_reduce :
                                  (module Monoid.S with type t = 'a) ->
                                  'T.t ->
                                  f:('-> ('a, 'e) t) -> ('a, 'e) t
                                val find :
                                  'T.t ->
                                  f:('-> (bool, 'e) t) ->
                                  ('Option.t, 'e) t
                                val find_map :
                                  'T.t ->
                                  f:('-> ('Option.t, 'e) t) ->
                                  ('Option.t, 'e) t
                                val filter :
                                  'T.t ->
                                  f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                                val filter_map :
                                  'T.t ->
                                  f:('-> ('Option.t, 'e) t) ->
                                  ('T.t, 'e) t
                              end
                        end
                      module List :
                        sig
                          val all : ('a, 'e) t List.t -> ('List.t, 'e) t
                          val all_ignore :
                            ('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                          val sequence :
                            (Monoid.Unit.t, 'e) t List.t ->
                            (Monoid.Unit.t, 'e) t
                          val map :
                            'List.t ->
                            f:('-> ('b, 'e) t) -> ('List.t, 'e) t
                          val iter :
                            'List.t ->
                            f:('-> (Monoid.Unit.t, 'e) t) ->
                            (Monoid.Unit.t, 'e) t
                          val fold :
                            'List.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_left :
                            'List.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_right :
                            'List.t ->
                            f:('-> '-> ('b, 'e) t) ->
                            init:'-> ('b, 'e) t
                          val reduce :
                            'List.t ->
                            f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                          val exists :
                            'List.t ->
                            f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val for_all :
                            'List.t ->
                            f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val count :
                            'List.t ->
                            f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                          val find :
                            'List.t ->
                            f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                          val find_map :
                            'List.t ->
                            f:('-> ('Option.t, 'e) t) ->
                            ('Option.t, 'e) t
                          val filter :
                            'List.t ->
                            f:('-> (bool, 'e) t) -> ('List.t, 'e) t
                          val filter_map :
                            'List.t ->
                            f:('-> ('Option.t, 'e) t) ->
                            ('List.t, 'e) t
                        end
                      module Seq :
                        sig
                          val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
                          val all_ignore :
                            ('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                          val sequence :
                            (Monoid.Unit.t, 'e) t Seq.t ->
                            (Monoid.Unit.t, 'e) t
                          val map :
                            'Seq.t ->
                            f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
                          val iter :
                            'Seq.t ->
                            f:('-> (Monoid.Unit.t, 'e) t) ->
                            (Monoid.Unit.t, 'e) t
                          val fold :
                            'Seq.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_left :
                            'Seq.t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_right :
                            'Seq.t ->
                            f:('-> '-> ('b, 'e) t) ->
                            init:'-> ('b, 'e) t
                          val reduce :
                            'Seq.t ->
                            f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                          val exists :
                            'Seq.t ->
                            f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val for_all :
                            'Seq.t ->
                            f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val count :
                            'Seq.t ->
                            f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                          val find :
                            'Seq.t ->
                            f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                          val find_map :
                            'Seq.t ->
                            f:('-> ('Option.t, 'e) t) ->
                            ('Option.t, 'e) t
                          val filter :
                            'Seq.t ->
                            f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
                          val filter_map :
                            'Seq.t ->
                            f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
                        end
                      val ( >=> ) :
                        ('-> ('b, 'e) t) ->
                        ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                      val ( !! ) : '-> ('a, 'e) t
                      val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                      val ( !$$ ) :
                        ('-> '-> 'c) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        ('a, 's) t ->
                        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        ('a, 's) t ->
                        ('b, 's) t ->
                        ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      module Let_syntax :
                        sig
                          val return : '-> ('a, 'b) t
                          val ( >>= ) :
                            ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                          val ( >>| ) :
                            ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                          module Let_syntax :
                            sig
                              val return : '-> ('a, 'b) t
                              val bind :
                                ('a, 'e) t ->
                                f:('-> ('b, 'e) t) -> ('b, 'e) t
                              val map :
                                ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                              val both :
                                ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                              module Open_on_rhs : sig  end
                            end
                        end
                      module Monad_infix :
                        sig
                          val ( >>= ) :
                            ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                          val ( >>| ) :
                            ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                        end
                      val bind :
                        ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                      val return : '-> ('a, 'b) t
                      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                      val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                      val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                      val all : ('a, 'e) t list -> ('a list, 'e) t
                      val all_ignore :
                        (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                      module Syntax :
                        sig
                          val ( >>= ) :
                            ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                          val ( >>| ) :
                            ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                          val ( >=> ) :
                            ('-> ('b, 'e) t) ->
                            ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                          val ( !! ) : '-> ('a, 'e) t
                          val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                          val ( !$$ ) :
                            ('-> '-> 'c) ->
                            ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                          val ( !$$$ ) :
                            ('-> '-> '-> 'd) ->
                            ('a, 'e) t ->
                            ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                          val ( !$$$$ ) :
                            ('-> '-> '-> '-> 'e) ->
                            ('a, 's) t ->
                            ('b, 's) t ->
                            ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                          val ( !$$$$$ ) :
                            ('-> '-> '-> '-> '-> 'f) ->
                            ('a, 's) t ->
                            ('b, 's) t ->
                            ('c, 's) t ->
                            ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                        end
                      val put : '-> (Monoid.Unit.t, 's) t
                      val get : Monoid.Unit.t -> ('s, 's) t
                      val gets : ('-> 'r) -> ('r, 's) t
                      val update : ('-> 's) -> (Monoid.Unit.t, 's) t
                    end
                  module T1 :
                    functor (T : Core_kernel.Std.T) (M : Monad->
                      sig
                        type env = T.t
                        type 'a m = 'M.t
                        type 'a t =
                            (('a,
                              Monads.Std.Monad.State.Multi.T1.env
                              Monads.Std.Monad.State.Multi.contexts)
                             Monads.Std.Monad.State.storage
                             Monads.Std.Monad.State.Multi.T1.m,
                             Monads.Std.Monad.State.Multi.T1.env
                             Monads.Std.Monad.State.Multi.contexts)
                            Monads.Std.Monad.State.state
                        type 'a e =
                            Monads.Std.Monad.State.Multi.T1.env ->
                            ('a * Monads.Std.Monad.State.Multi.T1.env)
                            Monads.Std.Monad.State.Multi.T1.m
                      end
                  module T2 :
                    functor (M : Monad->
                      sig
                        type 'a m = 'M.t
                        type ('a, 'e) t =
                            (('a, 'Monads.Std.Monad.State.Multi.contexts)
                             Monads.Std.Monad.State.storage
                             Monads.Std.Monad.State.Multi.T2.m,
                             'Monads.Std.Monad.State.Multi.contexts)
                            Monads.Std.Monad.State.state
                        type ('a, 'e) e =
                            '-> ('a * 'e) Monads.Std.Monad.State.Multi.T2.m
                      end
                  module Make :
                    functor (T : Core_kernel.Std.T) (M : Monad->
                      sig
                        val global : id
                        val fork : Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t
                        val switch : id -> Monoid.Unit.t T1(T)(M).t
                        val parent : Monoid.Unit.t -> id T1(T)(M).t
                        val ancestor : id List.t -> id T1(T)(M).t
                        val current : Monoid.Unit.t -> id T1(T)(M).t
                        val kill : id -> Monoid.Unit.t T1(T)(M).t
                        val forks : Monoid.Unit.t -> id Seq.t T1(T)(M).t
                        val status : id -> status T1(T)(M).t
                        val lift : 'M.t -> 'T1(T)(M).t
                        val run : 'T1(T)(M).t -> 'T1(T)(M).e
                        val void : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                        val sequence :
                          Monoid.Unit.t T1(T)(M).t List.t ->
                          Monoid.Unit.t T1(T)(M).t
                        val forever : 'T1(T)(M).t -> 'T1(T)(M).t
                        module Fn :
                          sig
                            val id : '-> 'T1(T)(M).t
                            val ignore :
                              'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                            val nothing :
                              Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t
                            val non :
                              ('-> bool T1(T)(M).t) ->
                              '-> bool T1(T)(M).t
                            val apply_n_times :
                              n:Monoid.Int.t ->
                              ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                            val compose :
                              ('-> 'T1(T)(M).t) ->
                              ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                          end
                        module Pair :
                          sig
                            val fst : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                            val snd : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                          end
                        module Triple :
                          sig
                            val fst :
                              ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                            val snd :
                              ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                            val trd :
                              ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                          end
                        module Lift :
                          sig
                            val nullary : '-> 'T1(T)(M).t
                            val unary :
                              ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                            val binary :
                              ('-> '-> 'c) ->
                              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                            val ternary :
                              ('-> '-> '-> 'd) ->
                              'T1(T)(M).t ->
                              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                            val quaternary :
                              ('-> '-> '-> '-> 'e) ->
                              'T1(T)(M).t ->
                              'T1(T)(M).t ->
                              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                            val quinary :
                              ('-> '-> '-> '-> '-> 'f) ->
                              'T1(T)(M).t ->
                              'T1(T)(M).t ->
                              'T1(T)(M).t ->
                              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                          end
                        module Exn :
                          sig
                            val expect :
                              ?finally:(Monoid.Unit.t ->
                                        Monoid.Unit.t T1(T)(M).t) ->
                              f:(Monoid.Unit.t -> 'T1(T)(M).t) ->
                              catch:(exn -> 'T1(T)(M).t) -> 'T1(T)(M).t
                          end
                        module Collection :
                          sig
                            module type S =
                              sig
                                type 'a t
                                val all : 'T1(T)(M).t t -> 'a t T1(T)(M).t
                                val all_ignore :
                                  'T1(T)(M).t t -> Monoid.Unit.t T1(T)(M).t
                                val sequence :
                                  Monoid.Unit.t T1(T)(M).t t ->
                                  Monoid.Unit.t T1(T)(M).t
                                val map :
                                  'a t ->
                                  f:('-> 'T1(T)(M).t) -> 'b t T1(T)(M).t
                                val iter :
                                  'a t ->
                                  f:('-> Monoid.Unit.t T1(T)(M).t) ->
                                  Monoid.Unit.t T1(T)(M).t
                                val fold :
                                  'a t ->
                                  init:'->
                                  f:('-> '-> 'T1(T)(M).t) ->
                                  'T1(T)(M).t
                                val fold_left :
                                  'a t ->
                                  init:'->
                                  f:('-> '-> 'T1(T)(M).t) ->
                                  'T1(T)(M).t
                                val fold_right :
                                  'a t ->
                                  f:('-> '-> 'T1(T)(M).t) ->
                                  init:'-> 'T1(T)(M).t
                                val reduce :
                                  'a t ->
                                  f:('-> '-> 'T1(T)(M).t) ->
                                  'Option.t T1(T)(M).t
                                val exists :
                                  'a t ->
                                  f:('-> bool T1(T)(M).t) ->
                                  bool T1(T)(M).t
                                val for_all :
                                  'a t ->
                                  f:('-> bool T1(T)(M).t) ->
                                  bool T1(T)(M).t
                                val count :
                                  'a t ->
                                  f:('-> bool T1(T)(M).t) ->
                                  Monoid.Int.t T1(T)(M).t
                                val map_reduce :
                                  (module Monoid.S with type t = 'a) ->
                                  'b t ->
                                  f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                                val find :
                                  'a t ->
                                  f:('-> bool T1(T)(M).t) ->
                                  'Option.t T1(T)(M).t
                                val find_map :
                                  'a t ->
                                  f:('-> 'Option.t T1(T)(M).t) ->
                                  'Option.t T1(T)(M).t
                                val filter :
                                  'a t ->
                                  f:('-> bool T1(T)(M).t) ->
                                  'a t T1(T)(M).t
                                val filter_map :
                                  'a t ->
                                  f:('-> 'Option.t T1(T)(M).t) ->
                                  'b t T1(T)(M).t
                              end
                            module Eager :
                              functor (T : Collection.Eager->
                                sig
                                  val all :
                                    'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                                  val all_ignore :
                                    'T1(T)(M).t T.t ->
                                    Monoid.Unit.t T1(T)(M).t
                                  val sequence :
                                    Monoid.Unit.t T1(T)(M).t T.t ->
                                    Monoid.Unit.t T1(T)(M).t
                                  val map :
                                    'T.t ->
                                    f:('-> 'T1(T)(M).t) ->
                                    'T.t T1(T)(M).t
                                  val iter :
                                    'T.t ->
                                    f:('-> Monoid.Unit.t T1(T)(M).t) ->
                                    Monoid.Unit.t T1(T)(M).t
                                  val fold :
                                    'T.t ->
                                    init:'->
                                    f:('-> '-> 'T1(T)(M).t) ->
                                    'T1(T)(M).t
                                  val fold_left :
                                    'T.t ->
                                    init:'->
                                    f:('-> '-> 'T1(T)(M).t) ->
                                    'T1(T)(M).t
                                  val fold_right :
                                    'T.t ->
                                    f:('-> '-> 'T1(T)(M).t) ->
                                    init:'-> 'T1(T)(M).t
                                  val reduce :
                                    'T.t ->
                                    f:('-> '-> 'T1(T)(M).t) ->
                                    'Option.t T1(T)(M).t
                                  val exists :
                                    'T.t ->
                                    f:('-> bool T1(T)(M).t) ->
                                    bool T1(T)(M).t
                                  val for_all :
                                    'T.t ->
                                    f:('-> bool T1(T)(M).t) ->
                                    bool T1(T)(M).t
                                  val count :
                                    'T.t ->
                                    f:('-> bool T1(T)(M).t) ->
                                    Monoid.Int.t T1(T)(M).t
                                  val map_reduce :
                                    (module Monoid.S with type t = 'a) ->
                                    'T.t ->
                                    f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                                  val find :
                                    'T.t ->
                                    f:('-> bool T1(T)(M).t) ->
                                    'Option.t T1(T)(M).t
                                  val find_map :
                                    'T.t ->
                                    f:('-> 'Option.t T1(T)(M).t) ->
                                    'Option.t T1(T)(M).t
                                  val filter :
                                    'T.t ->
                                    f:('-> bool T1(T)(M).t) ->
                                    'T.t T1(T)(M).t
                                  val filter_map :
                                    'T.t ->
                                    f:('-> 'Option.t T1(T)(M).t) ->
                                    'T.t T1(T)(M).t
                                end
                            module Delay :
                              functor (T : Collection.Delay->
                                sig
                                  val all :
                                    'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                                  val all_ignore :
                                    'T1(T)(M).t T.t ->
                                    Monoid.Unit.t T1(T)(M).t
                                  val sequence :
                                    Monoid.Unit.t T1(T)(M).t T.t ->
                                    Monoid.Unit.t T1(T)(M).t
                                  val map :
                                    'T.t ->
                                    f:('-> 'T1(T)(M).t) ->
                                    'T.t T1(T)(M).t
                                  val iter :
                                    'T.t ->
                                    f:('-> Monoid.Unit.t T1(T)(M).t) ->
                                    Monoid.Unit.t T1(T)(M).t
                                  val fold :
                                    'T.t ->
                                    init:'->
                                    f:('-> '-> 'T1(T)(M).t) ->
                                    'T1(T)(M).t
                                  val fold_left :
                                    'T.t ->
                                    init:'->
                                    f:('-> '-> 'T1(T)(M).t) ->
                                    'T1(T)(M).t
                                  val fold_right :
                                    'T.t ->
                                    f:('-> '-> 'T1(T)(M).t) ->
                                    init:'-> 'T1(T)(M).t
                                  val reduce :
                                    'T.t ->
                                    f:('-> '-> 'T1(T)(M).t) ->
                                    'Option.t T1(T)(M).t
                                  val exists :
                                    'T.t ->
                                    f:('-> bool T1(T)(M).t) ->
                                    bool T1(T)(M).t
                                  val for_all :
                                    'T.t ->
                                    f:('-> bool T1(T)(M).t) ->
                                    bool T1(T)(M).t
                                  val count :
                                    'T.t ->
                                    f:('-> bool T1(T)(M).t) ->
                                    Monoid.Int.t T1(T)(M).t
                                  val map_reduce :
                                    (module Monoid.S with type t = 'a) ->
                                    'T.t ->
                                    f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                                  val find :
                                    'T.t ->
                                    f:('-> bool T1(T)(M).t) ->
                                    'Option.t T1(T)(M).t
                                  val find_map :
                                    'T.t ->
                                    f:('-> 'Option.t T1(T)(M).t) ->
                                    'Option.t T1(T)(M).t
                                  val filter :
                                    'T.t ->
                                    f:('-> bool T1(T)(M).t) ->
                                    'T.t T1(T)(M).t
                                  val filter_map :
                                    'T.t ->
                                    f:('-> 'Option.t T1(T)(M).t) ->
                                    'T.t T1(T)(M).t
                                end
                          end
                        module List :
                          sig
                            val all :
                              'T1(T)(M).t List.t -> 'List.t T1(T)(M).t
                            val all_ignore :
                              'T1(T)(M).t List.t ->
                              Monoid.Unit.t T1(T)(M).t
                            val sequence :
                              Monoid.Unit.t T1(T)(M).t List.t ->
                              Monoid.Unit.t T1(T)(M).t
                            val map :
                              'List.t ->
                              f:('-> 'T1(T)(M).t) -> 'List.t T1(T)(M).t
                            val iter :
                              'List.t ->
                              f:('-> Monoid.Unit.t T1(T)(M).t) ->
                              Monoid.Unit.t T1(T)(M).t
                            val fold :
                              'List.t ->
                              init:'->
                              f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val fold_left :
                              'List.t ->
                              init:'->
                              f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val fold_right :
                              'List.t ->
                              f:('-> '-> 'T1(T)(M).t) ->
                              init:'-> 'T1(T)(M).t
                            val reduce :
                              'List.t ->
                              f:('-> '-> 'T1(T)(M).t) ->
                              'Option.t T1(T)(M).t
                            val exists :
                              'List.t ->
                              f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                            val for_all :
                              'List.t ->
                              f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                            val count :
                              'List.t ->
                              f:('-> bool T1(T)(M).t) ->
                              Monoid.Int.t T1(T)(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'List.t ->
                              f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val find :
                              'List.t ->
                              f:('-> bool T1(T)(M).t) ->
                              'Option.t T1(T)(M).t
                            val find_map :
                              'List.t ->
                              f:('-> 'Option.t T1(T)(M).t) ->
                              'Option.t T1(T)(M).t
                            val filter :
                              'List.t ->
                              f:('-> bool T1(T)(M).t) ->
                              'List.t T1(T)(M).t
                            val filter_map :
                              'List.t ->
                              f:('-> 'Option.t T1(T)(M).t) ->
                              'List.t T1(T)(M).t
                          end
                        module Seq :
                          sig
                            val all :
                              'T1(T)(M).t Seq.t -> 'Seq.t T1(T)(M).t
                            val all_ignore :
                              'T1(T)(M).t Seq.t -> Monoid.Unit.t T1(T)(M).t
                            val sequence :
                              Monoid.Unit.t T1(T)(M).t Seq.t ->
                              Monoid.Unit.t T1(T)(M).t
                            val map :
                              'Seq.t ->
                              f:('-> 'T1(T)(M).t) -> 'Seq.t T1(T)(M).t
                            val iter :
                              'Seq.t ->
                              f:('-> Monoid.Unit.t T1(T)(M).t) ->
                              Monoid.Unit.t T1(T)(M).t
                            val fold :
                              'Seq.t ->
                              init:'->
                              f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val fold_left :
                              'Seq.t ->
                              init:'->
                              f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val fold_right :
                              'Seq.t ->
                              f:('-> '-> 'T1(T)(M).t) ->
                              init:'-> 'T1(T)(M).t
                            val reduce :
                              'Seq.t ->
                              f:('-> '-> 'T1(T)(M).t) ->
                              'Option.t T1(T)(M).t
                            val exists :
                              'Seq.t ->
                              f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                            val for_all :
                              'Seq.t ->
                              f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                            val count :
                              'Seq.t ->
                              f:('-> bool T1(T)(M).t) ->
                              Monoid.Int.t T1(T)(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'Seq.t ->
                              f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val find :
                              'Seq.t ->
                              f:('-> bool T1(T)(M).t) ->
                              'Option.t T1(T)(M).t
                            val find_map :
                              'Seq.t ->
                              f:('-> 'Option.t T1(T)(M).t) ->
                              'Option.t T1(T)(M).t
                            val filter :
                              'Seq.t ->
                              f:('-> bool T1(T)(M).t) ->
                              'Seq.t T1(T)(M).t
                            val filter_map :
                              'Seq.t ->
                              f:('-> 'Option.t T1(T)(M).t) ->
                              'Seq.t T1(T)(M).t
                          end
                        val ( >=> ) :
                          ('-> 'T1(T)(M).t) ->
                          ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                        val ( !! ) : '-> 'T1(T)(M).t
                        val ( !$ ) :
                          ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( >>= ) :
                          'T1(T)(M).t ->
                          ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val ( >>| ) :
                          'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                        module Monad_infix :
                          sig
                            val ( >>= ) :
                              'T1(T)(M).t ->
                              ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val ( >>| ) :
                              'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                          end
                        val bind :
                          'T1(T)(M).t ->
                          f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val return : '-> 'T1(T)(M).t
                        val map :
                          'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                        val join : 'T1(T)(M).t T1(T)(M).t -> 'T1(T)(M).t
                        val ignore_m :
                          'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                        val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                        val all_ignore :
                          Monoid.Unit.t T1(T)(M).t list ->
                          Monoid.Unit.t T1(T)(M).t
                        module Let_syntax :
                          sig
                            val return : '-> 'T1(T)(M).t
                            val ( >>= ) :
                              'T1(T)(M).t ->
                              ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val ( >>| ) :
                              'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                            module Let_syntax :
                              sig
                                val return : '-> 'T1(T)(M).t
                                val bind :
                                  'T1(T)(M).t ->
                                  f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                                val map :
                                  'T1(T)(M).t ->
                                  f:('-> 'b) -> 'T1(T)(M).t
                                val both :
                                  'T1(T)(M).t ->
                                  'T1(T)(M).t -> ('a * 'b) T1(T)(M).t
                                module Open_on_rhs : sig  end
                              end
                          end
                        module Syntax :
                          sig
                            val ( >>= ) :
                              'T1(T)(M).t ->
                              ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val ( >>| ) :
                              'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                            val ( >=> ) :
                              ('-> 'T1(T)(M).t) ->
                              ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                            val ( !! ) : '-> 'T1(T)(M).t
                            val ( !$ ) :
                              ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                            val ( !$$ ) :
                              ('-> '-> 'c) ->
                              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                            val ( !$$$ ) :
                              ('-> '-> '-> 'd) ->
                              'T1(T)(M).t ->
                              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                            val ( !$$$$ ) :
                              ('-> '-> '-> '-> 'e) ->
                              'T1(T)(M).t ->
                              'T1(T)(M).t ->
                              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                            val ( !$$$$$ ) :
                              ('-> '-> '-> '-> '-> 'f) ->
                              'T1(T)(M).t ->
                              'T1(T)(M).t ->
                              'T1(T)(M).t ->
                              'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                          end
                        val put : T.t -> Monoid.Unit.t T1(T)(M).t
                        val get : Monoid.Unit.t -> T.t T1(T)(M).t
                        val gets : (T.t -> 'r) -> 'T1(T)(M).t
                        val update : (T.t -> T.t) -> Monoid.Unit.t T1(T)(M).t
                      end
                  module Make2 :
                    functor (M : Monad->
                      sig
                        val global : id
                        val fork :
                          Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
                        val switch : id -> (Monoid.Unit.t, 'e) T2(M).t
                        val parent : Monoid.Unit.t -> (id, 'e) T2(M).t
                        val ancestor : id List.t -> (id, 'e) T2(M).t
                        val current : Monoid.Unit.t -> (id, 'e) T2(M).t
                        val kill : id -> (Monoid.Unit.t, 'e) T2(M).t
                        val forks : Monoid.Unit.t -> (id Seq.t, 'e) T2(M).t
                        val status : id -> (status, 'e) T2(M).t
                        val lift : 'M.t -> ('a, 'e) T2(M).t
                        val run : ('a, 'e) T2(M).t -> ('a, 'e) T2(M).e
                        val void :
                          ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t List.t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        module Fn :
                          sig
                            val id : '-> ('a, 'e) T2(M).t
                            val ignore :
                              ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                            val nothing :
                              Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
                            val non :
                              ('-> (bool, 'e) T2(M).t) ->
                              '-> (bool, 'e) T2(M).t
                            val apply_n_times :
                              n:Monoid.Int.t ->
                              ('-> ('a, 'e) T2(M).t) ->
                              '-> ('a, 'e) T2(M).t
                            val compose :
                              ('-> ('c, 'e) T2(M).t) ->
                              ('-> ('b, 'e) T2(M).t) ->
                              '-> ('c, 'e) T2(M).t
                          end
                        module Pair :
                          sig
                            val fst :
                              ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                            val snd :
                              ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
                          end
                        module Triple :
                          sig
                            val fst :
                              ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                            val snd :
                              ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                            val trd :
                              ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
                          end
                        module Lift :
                          sig
                            val nullary : '-> ('a, 'e) T2(M).t
                            val unary :
                              ('-> 'b) ->
                              ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                            val binary :
                              ('-> '-> 'c) ->
                              ('a, 'e) T2(M).t ->
                              ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                            val ternary :
                              ('-> '-> '-> 'd) ->
                              ('a, 'e) T2(M).t ->
                              ('b, 'e) T2(M).t ->
                              ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                            val quaternary :
                              ('-> '-> '-> '-> 'e) ->
                              ('a, 's) T2(M).t ->
                              ('b, 's) T2(M).t ->
                              ('c, 's) T2(M).t ->
                              ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                            val quinary :
                              ('-> '-> '-> '-> '-> 'f) ->
                              ('a, 's) T2(M).t ->
                              ('b, 's) T2(M).t ->
                              ('c, 's) T2(M).t ->
                              ('d, 's) T2(M).t ->
                              ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                          end
                        module Exn :
                          sig
                            val expect :
                              ?finally:(Monoid.Unit.t ->
                                        (Monoid.Unit.t, 's) T2(M).t) ->
                              f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
                              catch:(exn -> ('a, 's) T2(M).t) ->
                              ('a, 's) T2(M).t
                          end
                        module Collection :
                          sig
                            module type S =
                              sig
                                type 'a t
                                val all :
                                  ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                                val all_ignore :
                                  ('a, 'e) T2(M).t t ->
                                  (Monoid.Unit.t, 'e) T2(M).t
                                val sequence :
                                  (Monoid.Unit.t, 'e) T2(M).t t ->
                                  (Monoid.Unit.t, 'e) T2(M).t
                                val map :
                                  'a t ->
                                  f:('-> ('b, 'e) T2(M).t) ->
                                  ('b t, 'e) T2(M).t
                                val iter :
                                  'a t ->
                                  f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                                  (Monoid.Unit.t, 'e) T2(M).t
                                val fold :
                                  'a t ->
                                  init:'->
                                  f:('-> '-> ('b, 'e) T2(M).t) ->
                                  ('b, 'e) T2(M).t
                                val fold_left :
                                  'a t ->
                                  init:'->
                                  f:('-> '-> ('b, 'e) T2(M).t) ->
                                  ('b, 'e) T2(M).t
                                val fold_right :
                                  'a t ->
                                  f:('-> '-> ('b, 'e) T2(M).t) ->
                                  init:'-> ('b, 'e) T2(M).t
                                val reduce :
                                  'a t ->
                                  f:('-> '-> ('a, 'e) T2(M).t) ->
                                  ('Option.t, 'e) T2(M).t
                                val exists :
                                  'a t ->
                                  f:('-> (bool, 'e) T2(M).t) ->
                                  (bool, 'e) T2(M).t
                                val for_all :
                                  'a t ->
                                  f:('-> (bool, 'e) T2(M).t) ->
                                  (bool, 'e) T2(M).t
                                val count :
                                  'a t ->
                                  f:('-> (bool, 'e) T2(M).t) ->
                                  (Monoid.Int.t, 'e) T2(M).t
                                val map_reduce :
                                  (module Monoid.S with type t = 'a) ->
                                  'b t ->
                                  f:('-> ('a, 'e) T2(M).t) ->
                                  ('a, 'e) T2(M).t
                                val find :
                                  'a t ->
                                  f:('-> (bool, 'e) T2(M).t) ->
                                  ('Option.t, 'e) T2(M).t
                                val find_map :
                                  'a t ->
                                  f:('-> ('Option.t, 'e) T2(M).t) ->
                                  ('Option.t, 'e) T2(M).t
                                val filter :
                                  'a t ->
                                  f:('-> (bool, 'e) T2(M).t) ->
                                  ('a t, 'e) T2(M).t
                                val filter_map :
                                  'a t ->
                                  f:('-> ('Option.t, 'e) T2(M).t) ->
                                  ('b t, 'e) T2(M).t
                              end
                            module Eager :
                              functor (T : Collection.Eager->
                                sig
                                  val all :
                                    ('a, 'e) T2(M).t T.t ->
                                    ('T.t, 'e) T2(M).t
                                  val all_ignore :
                                    ('a, 'e) T2(M).t T.t ->
                                    (Monoid.Unit.t, 'e) T2(M).t
                                  val sequence :
                                    (Monoid.Unit.t, 'e) T2(M).t T.t ->
                                    (Monoid.Unit.t, 'e) T2(M).t
                                  val map :
                                    'T.t ->
                                    f:('-> ('b, 'e) T2(M).t) ->
                                    ('T.t, 'e) T2(M).t
                                  val iter :
                                    'T.t ->
                                    f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                                    (Monoid.Unit.t, 'e) T2(M).t
                                  val fold :
                                    'T.t ->
                                    init:'->
                                    f:('-> '-> ('b, 'e) T2(M).t) ->
                                    ('b, 'e) T2(M).t
                                  val fold_left :
                                    'T.t ->
                                    init:'->
                                    f:('-> '-> ('b, 'e) T2(M).t) ->
                                    ('b, 'e) T2(M).t
                                  val fold_right :
                                    'T.t ->
                                    f:('-> '-> ('b, 'e) T2(M).t) ->
                                    init:'-> ('b, 'e) T2(M).t
                                  val reduce :
                                    'T.t ->
                                    f:('-> '-> ('a, 'e) T2(M).t) ->
                                    ('Option.t, 'e) T2(M).t
                                  val exists :
                                    'T.t ->
                                    f:('-> (bool, 'e) T2(M).t) ->
                                    (bool, 'e) T2(M).t
                                  val for_all :
                                    'T.t ->
                                    f:('-> (bool, 'e) T2(M).t) ->
                                    (bool, 'e) T2(M).t
                                  val count :
                                    'T.t ->
                                    f:('-> (bool, 'e) T2(M).t) ->
                                    (Monoid.Int.t, 'e) T2(M).t
                                  val map_reduce :
                                    (module Monoid.S with type t = 'a) ->
                                    'T.t ->
                                    f:('-> ('a, 'e) T2(M).t) ->
                                    ('a, 'e) T2(M).t
                                  val find :
                                    'T.t ->
                                    f:('-> (bool, 'e) T2(M).t) ->
                                    ('Option.t, 'e) T2(M).t
                                  val find_map :
                                    'T.t ->
                                    f:('-> ('Option.t, 'e) T2(M).t) ->
                                    ('Option.t, 'e) T2(M).t
                                  val filter :
                                    'T.t ->
                                    f:('-> (bool, 'e) T2(M).t) ->
                                    ('T.t, 'e) T2(M).t
                                  val filter_map :
                                    'T.t ->
                                    f:('-> ('Option.t, 'e) T2(M).t) ->
                                    ('T.t, 'e) T2(M).t
                                end
                            module Delay :
                              functor (T : Collection.Delay->
                                sig
                                  val all :
                                    ('a, 'e) T2(M).t T.t ->
                                    ('T.t, 'e) T2(M).t
                                  val all_ignore :
                                    ('a, 'e) T2(M).t T.t ->
                                    (Monoid.Unit.t, 'e) T2(M).t
                                  val sequence :
                                    (Monoid.Unit.t, 'e) T2(M).t T.t ->
                                    (Monoid.Unit.t, 'e) T2(M).t
                                  val map :
                                    'T.t ->
                                    f:('-> ('b, 'e) T2(M).t) ->
                                    ('T.t, 'e) T2(M).t
                                  val iter :
                                    'T.t ->
                                    f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                                    (Monoid.Unit.t, 'e) T2(M).t
                                  val fold :
                                    'T.t ->
                                    init:'->
                                    f:('-> '-> ('b, 'e) T2(M).t) ->
                                    ('b, 'e) T2(M).t
                                  val fold_left :
                                    'T.t ->
                                    init:'->
                                    f:('-> '-> ('b, 'e) T2(M).t) ->
                                    ('b, 'e) T2(M).t
                                  val fold_right :
                                    'T.t ->
                                    f:('-> '-> ('b, 'e) T2(M).t) ->
                                    init:'-> ('b, 'e) T2(M).t
                                  val reduce :
                                    'T.t ->
                                    f:('-> '-> ('a, 'e) T2(M).t) ->
                                    ('Option.t, 'e) T2(M).t
                                  val exists :
                                    'T.t ->
                                    f:('-> (bool, 'e) T2(M).t) ->
                                    (bool, 'e) T2(M).t
                                  val for_all :
                                    'T.t ->
                                    f:('-> (bool, 'e) T2(M).t) ->
                                    (bool, 'e) T2(M).t
                                  val count :
                                    'T.t ->
                                    f:('-> (bool, 'e) T2(M).t) ->
                                    (Monoid.Int.t, 'e) T2(M).t
                                  val map_reduce :
                                    (module Monoid.S with type t = 'a) ->
                                    'T.t ->
                                    f:('-> ('a, 'e) T2(M).t) ->
                                    ('a, 'e) T2(M).t
                                  val find :
                                    'T.t ->
                                    f:('-> (bool, 'e) T2(M).t) ->
                                    ('Option.t, 'e) T2(M).t
                                  val find_map :
                                    'T.t ->
                                    f:('-> ('Option.t, 'e) T2(M).t) ->
                                    ('Option.t, 'e) T2(M).t
                                  val filter :
                                    'T.t ->
                                    f:('-> (bool, 'e) T2(M).t) ->
                                    ('T.t, 'e) T2(M).t
                                  val filter_map :
                                    'T.t ->
                                    f:('-> ('Option.t, 'e) T2(M).t) ->
                                    ('T.t, 'e) T2(M).t
                                end
                          end
                        module List :
                          sig
                            val all :
                              ('a, 'e) T2(M).t List.t ->
                              ('List.t, 'e) T2(M).t
                            val all_ignore :
                              ('a, 'e) T2(M).t List.t ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val sequence :
                              (Monoid.Unit.t, 'e) T2(M).t List.t ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val map :
                              'List.t ->
                              f:('-> ('b, 'e) T2(M).t) ->
                              ('List.t, 'e) T2(M).t
                            val iter :
                              'List.t ->
                              f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val fold :
                              'List.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              ('b, 'e) T2(M).t
                            val fold_left :
                              'List.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              ('b, 'e) T2(M).t
                            val fold_right :
                              'List.t ->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              init:'-> ('b, 'e) T2(M).t
                            val reduce :
                              'List.t ->
                              f:('-> '-> ('a, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val exists :
                              'List.t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (bool, 'e) T2(M).t
                            val for_all :
                              'List.t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (bool, 'e) T2(M).t
                            val count :
                              'List.t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (Monoid.Int.t, 'e) T2(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'List.t ->
                              f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                            val find :
                              'List.t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val find_map :
                              'List.t ->
                              f:('-> ('Option.t, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val filter :
                              'List.t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              ('List.t, 'e) T2(M).t
                            val filter_map :
                              'List.t ->
                              f:('-> ('Option.t, 'e) T2(M).t) ->
                              ('List.t, 'e) T2(M).t
                          end
                        module Seq :
                          sig
                            val all :
                              ('a, 'e) T2(M).t Seq.t ->
                              ('Seq.t, 'e) T2(M).t
                            val all_ignore :
                              ('a, 'e) T2(M).t Seq.t ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val sequence :
                              (Monoid.Unit.t, 'e) T2(M).t Seq.t ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val map :
                              'Seq.t ->
                              f:('-> ('b, 'e) T2(M).t) ->
                              ('Seq.t, 'e) T2(M).t
                            val iter :
                              'Seq.t ->
                              f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val fold :
                              'Seq.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              ('b, 'e) T2(M).t
                            val fold_left :
                              'Seq.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              ('b, 'e) T2(M).t
                            val fold_right :
                              'Seq.t ->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              init:'-> ('b, 'e) T2(M).t
                            val reduce :
                              'Seq.t ->
                              f:('-> '-> ('a, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val exists :
                              'Seq.t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (bool, 'e) T2(M).t
                            val for_all :
                              'Seq.t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (bool, 'e) T2(M).t
                            val count :
                              'Seq.t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (Monoid.Int.t, 'e) T2(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'Seq.t ->
                              f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                            val find :
                              'Seq.t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val find_map :
                              'Seq.t ->
                              f:('-> ('Option.t, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val filter :
                              'Seq.t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              ('Seq.t, 'e) T2(M).t
                            val filter_map :
                              'Seq.t ->
                              f:('-> ('Option.t, 'e) T2(M).t) ->
                              ('Seq.t, 'e) T2(M).t
                          end
                        val ( >=> ) :
                          ('-> ('b, 'e) T2(M).t) ->
                          ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                        val ( !! ) : '-> ('a, 'e) T2(M).t
                        val ( !$ ) :
                          ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t ->
                          ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t ->
                          ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                        module Let_syntax :
                          sig
                            val return : '-> ('a, 'b) T2(M).t
                            val ( >>= ) :
                              ('a, 'e) T2(M).t ->
                              ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                            val ( >>| ) :
                              ('a, 'e) T2(M).t ->
                              ('-> 'b) -> ('b, 'e) T2(M).t
                            module Let_syntax :
                              sig
                                val return : '-> ('a, 'b) T2(M).t
                                val bind :
                                  ('a, 'e) T2(M).t ->
                                  f:('-> ('b, 'e) T2(M).t) ->
                                  ('b, 'e) T2(M).t
                                val map :
                                  ('a, 'e) T2(M).t ->
                                  f:('-> 'b) -> ('b, 'e) T2(M).t
                                val both :
                                  ('a, 'e) T2(M).t ->
                                  ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                                module Open_on_rhs : sig  end
                              end
                          end
                        module Monad_infix :
                          sig
                            val ( >>= ) :
                              ('a, 'e) T2(M).t ->
                              ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                            val ( >>| ) :
                              ('a, 'e) T2(M).t ->
                              ('-> 'b) -> ('b, 'e) T2(M).t
                          end
                        val bind :
                          ('a, 'e) T2(M).t ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val return : '-> ('a, 'b) T2(M).t
                        val map :
                          ('a, 'e) T2(M).t ->
                          f:('-> 'b) -> ('b, 'e) T2(M).t
                        val join :
                          (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
                        val ignore_m :
                          ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                        val all :
                          ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                        val all_ignore :
                          (Monoid.Unit.t, 'e) T2(M).t list ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        module Syntax :
                          sig
                            val ( >>= ) :
                              ('a, 'e) T2(M).t ->
                              ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                            val ( >>| ) :
                              ('a, 'e) T2(M).t ->
                              ('-> 'b) -> ('b, 'e) T2(M).t
                            val ( >=> ) :
                              ('-> ('b, 'e) T2(M).t) ->
                              ('-> ('c, 'e) T2(M).t) ->
                              '-> ('c, 'e) T2(M).t
                            val ( !! ) : '-> ('a, 'e) T2(M).t
                            val ( !$ ) :
                              ('-> 'b) ->
                              ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                            val ( !$$ ) :
                              ('-> '-> 'c) ->
                              ('a, 'e) T2(M).t ->
                              ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                            val ( !$$$ ) :
                              ('-> '-> '-> 'd) ->
                              ('a, 'e) T2(M).t ->
                              ('b, 'e) T2(M).t ->
                              ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                            val ( !$$$$ ) :
                              ('-> '-> '-> '-> 'e) ->
                              ('a, 's) T2(M).t ->
                              ('b, 's) T2(M).t ->
                              ('c, 's) T2(M).t ->
                              ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                            val ( !$$$$$ ) :
                              ('-> '-> '-> '-> '-> 'f) ->
                              ('a, 's) T2(M).t ->
                              ('b, 's) T2(M).t ->
                              ('c, 's) T2(M).t ->
                              ('d, 's) T2(M).t ->
                              ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                          end
                        val put : '-> (Monoid.Unit.t, 's) T2(M).t
                        val get : Monoid.Unit.t -> ('s, 's) T2(M).t
                        val gets : ('-> 'r) -> ('r, 's) T2(M).t
                        val update :
                          ('-> 's) -> (Monoid.Unit.t, 's) T2(M).t
                      end
                end
              type ('a, 'e) t = (('a, 'e) storage, 'e) state
              type 'a m = 'a
              type ('a, 'e) e = '-> 'a * 'e
              val lift : '-> ('a, 'e) t
              val run : ('a, 'e) t -> ('a, 'e) e
              val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val sequence :
                (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
              val forever : ('a, 'e) t -> ('b, 'e) t
              module Fn :
                sig
                  val id : '-> ('a, 'e) t
                  val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                  val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                  val compose :
                    ('-> ('c, 'e) t) ->
                    ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                end
              module Pair :
                sig
                  val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                  val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                end
              module Lift :
                sig
                  val nullary : '-> ('a, 'e) t
                  val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val binary :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ternary :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                    f:(Monoid.Unit.t -> ('a, 's) t) ->
                    catch:(exn -> ('a, 's) t) -> ('a, 's) t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : ('a, 'e) t t -> ('a t, 'e) t
                      val all_ignore : ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
                      val map : 'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                      val iter :
                        'a t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'a t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'a t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'a t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'a t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'a t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'a t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'a t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                      val filter_map :
                        'a t -> f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) ->
                          ('Option.t, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) ->
                          ('Option.t, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                      end
                end
              module List :
                sig
                  val all : ('a, 'e) t List.t -> ('List.t, 'e) t
                  val all_ignore : ('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val map :
                    'List.t -> f:('-> ('b, 'e) t) -> ('List.t, 'e) t
                  val iter :
                    'List.t ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'List.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'List.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'List.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'List.t ->
                    f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists :
                    'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'List.t ->
                    f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'List.t ->
                    f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'List.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter :
                    'List.t -> f:('-> (bool, 'e) t) -> ('List.t, 'e) t
                  val filter_map :
                    'List.t ->
                    f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
                end
              module Seq :
                sig
                  val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
                  val all_ignore : ('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                  val map :
                    'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
                  val iter :
                    'Seq.t ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'Seq.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'Seq.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'Seq.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'Seq.t ->
                    f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists :
                    'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'Seq.t ->
                    f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'Seq.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'Seq.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter :
                    'Seq.t -> f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
                  val filter_map :
                    'Seq.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
                end
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val bind :
                        ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                      val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Monad_infix :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                end
              val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
              val return : '-> ('a, 'b) t
              val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
              val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
              val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val all : ('a, 'e) t list -> ('a list, 'e) t
              val all_ignore :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              module Syntax :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  val ( >=> ) :
                    ('-> ('b, 'e) t) ->
                    ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                  val ( !! ) : '-> ('a, 'e) t
                  val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
              val put : '-> (Monoid.Unit.t, 's) t
              val get : Monoid.Unit.t -> ('s, 's) t
              val gets : ('-> 'r) -> ('r, 's) t
              val update : ('-> 's) -> (Monoid.Unit.t, 's) t
              val eval : ('a, 'e) t -> '-> 'a
              val exec : ('a, 'e) t -> '-> 'e
              module T1 :
                functor (T : Core_kernel.Std.T) (M : Monad->
                  sig
                    type env = T.t
                    type 'a m = 'M.t
                    type 'a t =
                        (('a, Monads.Std.Monad.State.T1.env)
                         Monads.Std.Monad.State.storage
                         Monads.Std.Monad.State.T1.m,
                         Monads.Std.Monad.State.T1.env)
                        Monads.Std.Monad.State.state
                    type 'a e =
                        Monads.Std.Monad.State.T1.env ->
                        ('a * Monads.Std.Monad.State.T1.env)
                        Monads.Std.Monad.State.T1.m
                  end
              module T2 :
                functor (M : Monad->
                  sig
                    type 'a m = 'M.t
                    type ('a, 'e) t =
                        (('a, 'e) Monads.Std.Monad.State.storage
                         Monads.Std.Monad.State.T2.m, 'e)
                        Monads.Std.Monad.State.state
                    type ('a, 'e) e =
                        '-> ('a * 'e) Monads.Std.Monad.State.T2.m
                  end
              module Make :
                functor (T : Core_kernel.Std.T) (M : Monad->
                  sig
                    val lift : 'M.t -> 'T1(T)(M).t
                    val run : 'T1(T)(M).t -> 'T1(T)(M).e
                    val void : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                    val sequence :
                      Monoid.Unit.t T1(T)(M).t list ->
                      Monoid.Unit.t T1(T)(M).t
                    val forever : 'T1(T)(M).t -> 'T1(T)(M).t
                    module Fn :
                      sig
                        val id : '-> 'T1(T)(M).t
                        val ignore :
                          'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                        val nothing :
                          Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t
                        val non :
                          ('-> bool T1(T)(M).t) -> '-> bool T1(T)(M).t
                        val apply_n_times :
                          n:Monoid.Int.t ->
                          ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                        val compose :
                          ('-> 'T1(T)(M).t) ->
                          ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                      end
                    module Pair :
                      sig
                        val fst : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                        val snd : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                      end
                    module Triple :
                      sig
                        val fst : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                        val snd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                        val trd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                      end
                    module Lift :
                      sig
                        val nullary : '-> 'T1(T)(M).t
                        val unary :
                          ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val binary :
                          ('-> '-> 'c) ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ternary :
                          ('-> '-> '-> 'd) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val quaternary :
                          ('-> '-> '-> '-> 'e) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val quinary :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                      end
                    module Exn :
                      sig
                        val expect :
                          ?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t) ->
                          f:(Monoid.Unit.t -> 'T1(T)(M).t) ->
                          catch:(exn -> 'T1(T)(M).t) -> 'T1(T)(M).t
                      end
                    module Collection :
                      sig
                        module type S =
                          sig
                            type 'a t
                            val all : 'T1(T)(M).t t -> 'a t T1(T)(M).t
                            val all_ignore :
                              'T1(T)(M).t t -> Monoid.Unit.t T1(T)(M).t
                            val sequence :
                              Monoid.Unit.t T1(T)(M).t t ->
                              Monoid.Unit.t T1(T)(M).t
                            val map :
                              'a t ->
                              f:('-> 'T1(T)(M).t) -> 'b t T1(T)(M).t
                            val iter :
                              'a t ->
                              f:('-> Monoid.Unit.t T1(T)(M).t) ->
                              Monoid.Unit.t T1(T)(M).t
                            val fold :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val fold_left :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val fold_right :
                              'a t ->
                              f:('-> '-> 'T1(T)(M).t) ->
                              init:'-> 'T1(T)(M).t
                            val reduce :
                              'a t ->
                              f:('-> '-> 'T1(T)(M).t) ->
                              'Option.t T1(T)(M).t
                            val exists :
                              'a t ->
                              f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                            val for_all :
                              'a t ->
                              f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                            val count :
                              'a t ->
                              f:('-> bool T1(T)(M).t) ->
                              Monoid.Int.t T1(T)(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b t ->
                              f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val find :
                              'a t ->
                              f:('-> bool T1(T)(M).t) ->
                              'Option.t T1(T)(M).t
                            val find_map :
                              'a t ->
                              f:('-> 'Option.t T1(T)(M).t) ->
                              'Option.t T1(T)(M).t
                            val filter :
                              'a t ->
                              f:('-> bool T1(T)(M).t) -> 'a t T1(T)(M).t
                            val filter_map :
                              'a t ->
                              f:('-> 'Option.t T1(T)(M).t) ->
                              'b t T1(T)(M).t
                          end
                        module Eager :
                          functor (T : Collection.Eager->
                            sig
                              val all :
                                'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                              val all_ignore :
                                'T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
                              val sequence :
                                Monoid.Unit.t T1(T)(M).t T.t ->
                                Monoid.Unit.t T1(T)(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T1(T)(M).t) ->
                                Monoid.Unit.t T1(T)(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'T1(T)(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'T1(T)(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T1(T)(M).t) ->
                                init:'-> 'T1(T)(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                Monoid.Int.t T1(T)(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'Option.t T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                'T.t T1(T)(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'Option.t T1(T)(M).t) ->
                                'T.t T1(T)(M).t
                            end
                        module Delay :
                          functor (T : Collection.Delay->
                            sig
                              val all :
                                'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                              val all_ignore :
                                'T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
                              val sequence :
                                Monoid.Unit.t T1(T)(M).t T.t ->
                                Monoid.Unit.t T1(T)(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T1(T)(M).t) ->
                                Monoid.Unit.t T1(T)(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'T1(T)(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'T1(T)(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T1(T)(M).t) ->
                                init:'-> 'T1(T)(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                Monoid.Int.t T1(T)(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'Option.t T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                'T.t T1(T)(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'Option.t T1(T)(M).t) ->
                                'T.t T1(T)(M).t
                            end
                      end
                    module List :
                      sig
                        val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                        val all_ignore :
                          'T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
                        val sequence :
                          Monoid.Unit.t T1(T)(M).t list ->
                          Monoid.Unit.t T1(T)(M).t
                        val map :
                          'a list ->
                          f:('-> 'T1(T)(M).t) -> 'b list T1(T)(M).t
                        val iter :
                          'a list ->
                          f:('-> Monoid.Unit.t T1(T)(M).t) ->
                          Monoid.Unit.t T1(T)(M).t
                        val fold :
                          'a list ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_left :
                          'a list ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_right :
                          'a list ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          init:'-> 'T1(T)(M).t
                        val reduce :
                          'a list ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val exists :
                          'a list ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val for_all :
                          'a list ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val count :
                          'a list ->
                          f:('-> bool T1(T)(M).t) ->
                          Monoid.Int.t T1(T)(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b list -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val find :
                          'a list ->
                          f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                        val find_map :
                          'a list ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val filter :
                          'a list ->
                          f:('-> bool T1(T)(M).t) -> 'a list T1(T)(M).t
                        val filter_map :
                          'a list ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'b list T1(T)(M).t
                      end
                    module Seq :
                      sig
                        val all :
                          'T1(T)(M).t Core_kernel.Std.Sequence.t ->
                          'Core_kernel.Std.Sequence.t T1(T)(M).t
                        val all_ignore :
                          'T1(T)(M).t Core_kernel.Std.Sequence.t ->
                          Monoid.Unit.t T1(T)(M).t
                        val sequence :
                          Monoid.Unit.t T1(T)(M).t Core_kernel.Std.Sequence.t ->
                          Monoid.Unit.t T1(T)(M).t
                        val map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'T1(T)(M).t) ->
                          'Core_kernel.Std.Sequence.t T1(T)(M).t
                        val iter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> Monoid.Unit.t T1(T)(M).t) ->
                          Monoid.Unit.t T1(T)(M).t
                        val fold :
                          'Core_kernel.Std.Sequence.t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_left :
                          'Core_kernel.Std.Sequence.t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_right :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          init:'-> 'T1(T)(M).t
                        val reduce :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val exists :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val for_all :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val count :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(T)(M).t) ->
                          Monoid.Int.t T1(T)(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val find :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                        val find_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val filter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(T)(M).t) ->
                          'Core_kernel.Std.Sequence.t T1(T)(M).t
                        val filter_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'Core_kernel.Std.Sequence.t T1(T)(M).t
                      end
                    val ( >=> ) :
                      ('-> 'T1(T)(M).t) ->
                      ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                    val ( !! ) : '-> 'T1(T)(M).t
                    val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( >>= ) :
                      'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val ( >>| ) :
                      'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          'T1(T)(M).t ->
                          ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val ( >>| ) :
                          'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                      end
                    val bind :
                      'T1(T)(M).t ->
                      f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val return : '-> 'T1(T)(M).t
                    val map : 'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                    val join : 'T1(T)(M).t T1(T)(M).t -> 'T1(T)(M).t
                    val ignore_m : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                    val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                    val all_ignore :
                      Monoid.Unit.t T1(T)(M).t list ->
                      Monoid.Unit.t T1(T)(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T1(T)(M).t
                        val ( >>= ) :
                          'T1(T)(M).t ->
                          ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val ( >>| ) :
                          'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                        module Let_syntax :
                          sig
                            val return : '-> 'T1(T)(M).t
                            val bind :
                              'T1(T)(M).t ->
                              f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val map :
                              'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                            val both :
                              'T1(T)(M).t ->
                              'T1(T)(M).t -> ('a * 'b) T1(T)(M).t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Syntax :
                      sig
                        val ( >>= ) :
                          'T1(T)(M).t ->
                          ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val ( >>| ) :
                          'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                        val ( >=> ) :
                          ('-> 'T1(T)(M).t) ->
                          ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                        val ( !! ) : '-> 'T1(T)(M).t
                        val ( !$ ) :
                          ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                      end
                    val put : T.t -> Monoid.Unit.t T1(T)(M).t
                    val get : Monoid.Unit.t -> T.t T1(T)(M).t
                    val gets : (T.t -> 'r) -> 'T1(T)(M).t
                    val update : (T.t -> T.t) -> Monoid.Unit.t T1(T)(M).t
                  end
              module Make2 :
                functor (M : Monad->
                  sig
                    val lift : 'M.t -> ('a, 'e) T2(M).t
                    val run : ('a, 'e) T2(M).t -> ('a, 'e) T2(M).e
                    val void :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    module Fn :
                      sig
                        val id : '-> ('a, 'e) T2(M).t
                        val ignore :
                          ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                        val nothing :
                          Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
                        val non :
                          ('-> (bool, 'e) T2(M).t) ->
                          '-> (bool, 'e) T2(M).t
                        val apply_n_times :
                          n:Monoid.Int.t ->
                          ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                        val compose :
                          ('-> ('c, 'e) T2(M).t) ->
                          ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                      end
                    module Pair :
                      sig
                        val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                        val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
                      end
                    module Triple :
                      sig
                        val fst :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                        val snd :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val trd :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
                      end
                    module Lift :
                      sig
                        val nullary : '-> ('a, 'e) T2(M).t
                        val unary :
                          ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val binary :
                          ('-> '-> 'c) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                        val ternary :
                          ('-> '-> '-> 'd) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t ->
                          ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                        val quaternary :
                          ('-> '-> '-> '-> 'e) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                        val quinary :
                          ('-> '-> '-> '-> '-> 'f) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t ->
                          ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                      end
                    module Exn :
                      sig
                        val expect :
                          ?finally:(Monoid.Unit.t ->
                                    (Monoid.Unit.t, 's) T2(M).t) ->
                          f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
                          catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
                      end
                    module Collection :
                      sig
                        module type S =
                          sig
                            type 'a t
                            val all :
                              ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                            val all_ignore :
                              ('a, 'e) T2(M).t t ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val sequence :
                              (Monoid.Unit.t, 'e) T2(M).t t ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val map :
                              'a t ->
                              f:('-> ('b, 'e) T2(M).t) ->
                              ('b t, 'e) T2(M).t
                            val iter :
                              'a t ->
                              f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val fold :
                              'a t ->
                              init:'->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              ('b, 'e) T2(M).t
                            val fold_left :
                              'a t ->
                              init:'->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              ('b, 'e) T2(M).t
                            val fold_right :
                              'a t ->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              init:'-> ('b, 'e) T2(M).t
                            val reduce :
                              'a t ->
                              f:('-> '-> ('a, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val exists :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (bool, 'e) T2(M).t
                            val for_all :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (bool, 'e) T2(M).t
                            val count :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (Monoid.Int.t, 'e) T2(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b t ->
                              f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                            val find :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val find_map :
                              'a t ->
                              f:('-> ('Option.t, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val filter :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              ('a t, 'e) T2(M).t
                            val filter_map :
                              'a t ->
                              f:('-> ('Option.t, 'e) T2(M).t) ->
                              ('b t, 'e) T2(M).t
                          end
                        module Eager :
                          functor (T : Collection.Eager->
                            sig
                              val all :
                                ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                              val all_ignore :
                                ('a, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val sequence :
                                (Monoid.Unit.t, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val map :
                                'T.t ->
                                f:('-> ('b, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val iter :
                                'T.t ->
                                f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                init:'-> ('b, 'e) T2(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> ('a, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val exists :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val for_all :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val count :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (Monoid.Int.t, 'e) T2(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> ('a, 'e) T2(M).t) ->
                                ('a, 'e) T2(M).t
                              val find :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val find_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val filter :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                            end
                        module Delay :
                          functor (T : Collection.Delay->
                            sig
                              val all :
                                ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                              val all_ignore :
                                ('a, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val sequence :
                                (Monoid.Unit.t, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val map :
                                'T.t ->
                                f:('-> ('b, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val iter :
                                'T.t ->
                                f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                init:'-> ('b, 'e) T2(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> ('a, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val exists :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val for_all :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val count :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (Monoid.Int.t, 'e) T2(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> ('a, 'e) T2(M).t) ->
                                ('a, 'e) T2(M).t
                              val find :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val find_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val filter :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                            end
                      end
                    module List :
                      sig
                        val all :
                          ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t list ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t list ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'a list ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                        val iter :
                          'a list ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'a list ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'a list ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'a list ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'a list ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b list ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'a list ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('a list, 'e) T2(M).t
                        val filter_map :
                          'a list ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('b list, 'e) T2(M).t
                      end
                    module Seq :
                      sig
                        val all :
                          ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t
                          Core_kernel.Std.Sequence.t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('b, 'e) T2(M).t) ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                        val iter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'Core_kernel.Std.Sequence.t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'Core_kernel.Std.Sequence.t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                        val filter_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                      end
                    val ( >=> ) :
                      ('-> ('b, 'e) T2(M).t) ->
                      ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                    val ( !! ) : '-> ('a, 'e) T2(M).t
                    val ( !$ ) :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) T2(M).t
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                        module Let_syntax :
                          sig
                            val return : '-> ('a, 'b) T2(M).t
                            val bind :
                              ('a, 'e) T2(M).t ->
                              f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                            val map :
                              ('a, 'e) T2(M).t ->
                              f:('-> 'b) -> ('b, 'e) T2(M).t
                            val both :
                              ('a, 'e) T2(M).t ->
                              ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                      end
                    val bind :
                      ('a, 'e) T2(M).t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val return : '-> ('a, 'b) T2(M).t
                    val map :
                      ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                    val join :
                      (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val ignore_m :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                    val all_ignore :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    module Syntax :
                      sig
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                        val ( >=> ) :
                          ('-> ('b, 'e) T2(M).t) ->
                          ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                        val ( !! ) : '-> ('a, 'e) T2(M).t
                        val ( !$ ) :
                          ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t ->
                          ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t ->
                          ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                      end
                    val put : '-> (Monoid.Unit.t, 's) T2(M).t
                    val get : Monoid.Unit.t -> ('s, 's) T2(M).t
                    val gets : ('-> 'r) -> ('r, 's) T2(M).t
                    val update : ('-> 's) -> (Monoid.Unit.t, 's) T2(M).t
                  end
            end
          module Fun :
            sig
              module type S =
                sig
                  type 'a t
                  type 'a m
                  type 'a e
                  val lift : 'a m -> 'a t
                  val run : 'a t -> 'a e
                  val void : 'a t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
                  val forever : 'a t -> 'b t
                  module Fn :
                    sig
                      val id : '-> 'a t
                      val ignore : 'a t -> Monoid.Unit.t t
                      val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                      val non : ('-> bool t) -> '-> bool t
                      val apply_n_times :
                        n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                      val compose :
                        ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                    end
                  module Pair :
                    sig
                      val fst : ('a * 'b) t -> 'a t
                      val snd : ('a * 'b) t -> 'b t
                    end
                  module Triple :
                    sig
                      val fst : ('a * 'b * 'c) t -> 'a t
                      val snd : ('a * 'b * 'c) t -> 'b t
                      val trd : ('a * 'b * 'c) t -> 'c t
                    end
                  module Lift :
                    sig
                      val nullary : '-> 'a t
                      val unary : ('-> 'b) -> 'a t -> 'b t
                      val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ternary :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val quaternary :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val quinary :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                  module Exn :
                    sig
                      val expect :
                        ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                        f:(Monoid.Unit.t -> 'a t) ->
                        catch:(exn -> 'a t) -> 'a t
                    end
                  module Collection :
                    sig
                      module type S =
                        sig
                          type 'a t
                          val all : 'a t t -> 'a t t
                          val all_ignore : 'a t t -> Monoid.Unit.t t
                          val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                          val map : 'a t -> f:('-> 'b t) -> 'b t t
                          val iter :
                            'a t ->
                            f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                          val fold :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_left :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_right :
                            'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                          val reduce :
                            'a t -> f:('-> '-> 'a t) -> 'Option.t t
                          val exists : 'a t -> f:('-> bool t) -> bool t
                          val for_all : 'a t -> f:('-> bool t) -> bool t
                          val count :
                            'a t -> f:('-> bool t) -> Monoid.Int.t t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b t -> f:('-> 'a t) -> 'a t
                          val find :
                            'a t -> f:('-> bool t) -> 'Option.t t
                          val find_map :
                            'a t -> f:('-> 'Option.t t) -> 'Option.t t
                          val filter : 'a t -> f:('-> bool t) -> 'a t t
                          val filter_map :
                            'a t -> f:('-> 'Option.t t) -> 'b t t
                        end
                      module Eager :
                        functor (T : Collection.Eager->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'Option.t t
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t t) -> 'Option.t t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'Option.t t) -> 'T.t t
                          end
                      module Delay :
                        functor (T : Collection.Delay->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'Option.t t
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t t) -> 'Option.t t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'Option.t t) -> 'T.t t
                          end
                    end
                  module List :
                    sig
                      val all : 'a t List.t -> 'List.t t
                      val all_ignore : 'a t List.t -> Monoid.Unit.t t
                      val sequence :
                        Monoid.Unit.t t List.t -> Monoid.Unit.t t
                      val map : 'List.t -> f:('-> 'b t) -> 'List.t t
                      val iter :
                        'List.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'List.t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'List.t -> f:('-> bool t) -> bool t
                      val for_all : 'List.t -> f:('-> bool t) -> bool t
                      val count :
                        'List.t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'List.t -> f:('-> 'a t) -> 'a t
                      val find :
                        'List.t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'List.t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter :
                        'List.t -> f:('-> bool t) -> 'List.t t
                      val filter_map :
                        'List.t -> f:('-> 'Option.t t) -> 'List.t t
                    end
                  module Seq :
                    sig
                      val all : 'a t Seq.t -> 'Seq.t t
                      val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
                      val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
                      val iter :
                        'Seq.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'Seq.t -> f:('-> bool t) -> bool t
                      val for_all : 'Seq.t -> f:('-> bool t) -> bool t
                      val count :
                        'Seq.t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'Seq.t -> f:('-> 'a t) -> 'a t
                      val find :
                        'Seq.t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
                      val filter_map :
                        'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
                    end
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Monad_infix :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                    end
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val return : '-> 'a t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val join : 'a t t -> 'a t
                  val ignore_m : 'a t -> Monoid.Unit.t t
                  val all : 'a t list -> 'a list t
                  val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      module Let_syntax :
                        sig
                          val return : '-> 'a t
                          val bind : 'a t -> f:('-> 'b t) -> 'b t
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val both : 'a t -> 'b t -> ('a * 'b) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Syntax :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      val ( >=> ) :
                        ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                      val ( !! ) : '-> 'a t
                      val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                      val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                end
              module type S2 =
                sig
                  type ('a, 'e) t
                  type ('a, 'e) m
                  type ('a, 'e) e
                  val lift : ('a, 'e) m -> ('a, 'e) t
                  val run : ('a, 'e) t -> ('a, 'e) e
                  val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val forever : ('a, 'e) t -> ('b, 'e) t
                  module Fn :
                    sig
                      val id : '-> ('a, 'e) t
                      val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                      val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                      val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                      val apply_n_times :
                        n:Monoid.Int.t ->
                        ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                      val compose :
                        ('-> ('c, 'e) t) ->
                        ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                    end
                  module Pair :
                    sig
                      val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                      val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                    end
                  module Triple :
                    sig
                      val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                      val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                      val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                    end
                  module Lift :
                    sig
                      val nullary : '-> ('a, 'e) t
                      val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                      val binary :
                        ('-> '-> 'c) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                      val ternary :
                        ('-> '-> '-> 'd) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                      val quaternary :
                        ('-> '-> '-> '-> 'e) ->
                        ('a, 's) t ->
                        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                      val quinary :
                        ('-> '-> '-> '-> '-> 'f) ->
                        ('a, 's) t ->
                        ('b, 's) t ->
                        ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                    end
                  module Exn :
                    sig
                      val expect :
                        ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                        f:(Monoid.Unit.t -> ('a, 's) t) ->
                        catch:(exn -> ('a, 's) t) -> ('a, 's) t
                    end
                  module Collection :
                    sig
                      module type S =
                        sig
                          type 'a t
                          val all : ('a, 'e) t t -> ('a t, 'e) t
                          val all_ignore :
                            ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
                          val sequence :
                            (Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
                          val map :
                            'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                          val iter :
                            'a t ->
                            f:('-> (Monoid.Unit.t, 'e) t) ->
                            (Monoid.Unit.t, 'e) t
                          val fold :
                            'a t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_left :
                            'a t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_right :
                            'a t ->
                            f:('-> '-> ('b, 'e) t) ->
                            init:'-> ('b, 'e) t
                          val reduce :
                            'a t ->
                            f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                          val exists :
                            'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val for_all :
                            'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val count :
                            'a t ->
                            f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                          val find :
                            'a t ->
                            f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                          val find_map :
                            'a t ->
                            f:('-> ('Option.t, 'e) t) ->
                            ('Option.t, 'e) t
                          val filter :
                            'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                          val filter_map :
                            'a t ->
                            f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                        end
                      module Eager :
                        functor (T : Collection.Eager->
                          sig
                            val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                            val all_ignore :
                              ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                            val sequence :
                              (Monoid.Unit.t, 'e) t T.t ->
                              (Monoid.Unit.t, 'e) t
                            val map :
                              'T.t ->
                              f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                            val iter :
                              'T.t ->
                              f:('-> (Monoid.Unit.t, 'e) t) ->
                              (Monoid.Unit.t, 'e) t
                            val fold :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_left :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> ('b, 'e) t) ->
                              init:'-> ('b, 'e) t
                            val reduce :
                              'T.t ->
                              f:('-> '-> ('a, 'e) t) ->
                              ('Option.t, 'e) t
                            val exists :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val for_all :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val count :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                            val find :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                            val find_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) ->
                              ('Option.t, 'e) t
                            val filter :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                            val filter_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                          end
                      module Delay :
                        functor (T : Collection.Delay->
                          sig
                            val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                            val all_ignore :
                              ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                            val sequence :
                              (Monoid.Unit.t, 'e) t T.t ->
                              (Monoid.Unit.t, 'e) t
                            val map :
                              'T.t ->
                              f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                            val iter :
                              'T.t ->
                              f:('-> (Monoid.Unit.t, 'e) t) ->
                              (Monoid.Unit.t, 'e) t
                            val fold :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_left :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> ('b, 'e) t) ->
                              init:'-> ('b, 'e) t
                            val reduce :
                              'T.t ->
                              f:('-> '-> ('a, 'e) t) ->
                              ('Option.t, 'e) t
                            val exists :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val for_all :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val count :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                            val find :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                            val find_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) ->
                              ('Option.t, 'e) t
                            val filter :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                            val filter_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                          end
                    end
                  module List :
                    sig
                      val all : ('a, 'e) t List.t -> ('List.t, 'e) t
                      val all_ignore :
                        ('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                      val map :
                        'List.t ->
                        f:('-> ('b, 'e) t) -> ('List.t, 'e) t
                      val iter :
                        'List.t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'List.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'List.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'List.t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'List.t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'List.t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'List.t ->
                        f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'List.t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'List.t ->
                        f:('-> (bool, 'e) t) -> ('List.t, 'e) t
                      val filter_map :
                        'List.t ->
                        f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
                    end
                  module Seq :
                    sig
                      val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
                      val all_ignore :
                        ('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                      val map :
                        'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
                      val iter :
                        'Seq.t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'Seq.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'Seq.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'Seq.t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'Seq.t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'Seq.t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'Seq.t ->
                        f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'Seq.t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'Seq.t ->
                        f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
                      val filter_map :
                        'Seq.t ->
                        f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
                    end
                  val ( >=> ) :
                    ('-> ('b, 'e) t) ->
                    ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                  val ( !! ) : '-> ('a, 'e) t
                  val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      module Let_syntax :
                        sig
                          val return : '-> ('a, 'b) t
                          val bind :
                            ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                          val both :
                            ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Monad_infix :
                    sig
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                    end
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val return : '-> ('a, 'b) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                  val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val all : ('a, 'e) t list -> ('a list, 'e) t
                  val all_ignore :
                    (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                  module Syntax :
                    sig
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      val ( >=> ) :
                        ('-> ('b, 'e) t) ->
                        ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                      val ( !! ) : '-> ('a, 'e) t
                      val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                      val ( !$$ ) :
                        ('-> '-> 'c) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        ('a, 's) t ->
                        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        ('a, 's) t ->
                        ('b, 's) t ->
                        ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                    end
                end
              type 'a thunk
              type 'a t = 'a thunk
              type 'a m = 'a
              type 'a e = 'a
              val lift : '-> 'a t
              val run : 'a t -> 'a
              val void : 'a t -> Monoid.Unit.t t
              val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
              val forever : 'a t -> 'b t
              module Fn :
                sig
                  val id : '-> 'a t
                  val ignore : 'a t -> Monoid.Unit.t t
                  val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                  val non : ('-> bool t) -> '-> bool t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                  val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                end
              module Pair :
                sig
                  val fst : ('a * 'b) t -> 'a t
                  val snd : ('a * 'b) t -> 'b t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c) t -> 'a t
                  val snd : ('a * 'b * 'c) t -> 'b t
                  val trd : ('a * 'b * 'c) t -> 'c t
                end
              module Lift :
                sig
                  val nullary : '-> 'a t
                  val unary : ('-> 'b) -> 'a t -> 'b t
                  val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ternary :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                    f:(Monoid.Unit.t -> 'a t) -> catch:(exn -> 'a t) -> 'a t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : 'a thunk t -> 'a t thunk
                      val all_ignore : 'a thunk t -> Monoid.Unit.t thunk
                      val sequence :
                        Monoid.Unit.t thunk t -> Monoid.Unit.t thunk
                      val map : 'a t -> f:('-> 'b thunk) -> 'b t thunk
                      val iter :
                        'a t ->
                        f:('-> Monoid.Unit.t thunk) -> Monoid.Unit.t thunk
                      val fold :
                        'a t ->
                        init:'-> f:('-> '-> 'b thunk) -> 'b thunk
                      val fold_left :
                        'a t ->
                        init:'-> f:('-> '-> 'b thunk) -> 'b thunk
                      val fold_right :
                        'a t ->
                        f:('-> '-> 'b thunk) -> init:'-> 'b thunk
                      val reduce :
                        'a t -> f:('-> '-> 'a thunk) -> 'Option.t thunk
                      val exists : 'a t -> f:('-> bool thunk) -> bool thunk
                      val for_all :
                        'a t -> f:('-> bool thunk) -> bool thunk
                      val count :
                        'a t -> f:('-> bool thunk) -> Monoid.Int.t thunk
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> 'a thunk) -> 'a thunk
                      val find :
                        'a t -> f:('-> bool thunk) -> 'Option.t thunk
                      val find_map :
                        'a t ->
                        f:('-> 'Option.t thunk) -> 'Option.t thunk
                      val filter : 'a t -> f:('-> bool thunk) -> 'a t thunk
                      val filter_map :
                        'a t -> f:('-> 'Option.t thunk) -> 'b t thunk
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                end
              module List :
                sig
                  val all : 'a t List.t -> 'List.t t
                  val all_ignore : 'a t List.t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
                  val map : 'List.t -> f:('-> 'b t) -> 'List.t t
                  val iter :
                    'List.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'List.t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'List.t -> f:('-> bool t) -> bool t
                  val for_all : 'List.t -> f:('-> bool t) -> bool t
                  val count : 'List.t -> f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'List.t -> f:('-> 'a t) -> 'a t
                  val find : 'List.t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'List.t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'List.t -> f:('-> bool t) -> 'List.t t
                  val filter_map :
                    'List.t -> f:('-> 'Option.t t) -> 'List.t t
                end
              module Seq :
                sig
                  val all : 'a t Seq.t -> 'Seq.t t
                  val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
                  val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
                  val iter :
                    'Seq.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'Seq.t -> f:('-> bool t) -> bool t
                  val for_all : 'Seq.t -> f:('-> bool t) -> bool t
                  val count : 'Seq.t -> f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Seq.t -> f:('-> 'a t) -> 'a t
                  val find : 'Seq.t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
                  val filter_map :
                    'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
                end
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Monad_infix :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                end
              val bind : 'a t -> f:('-> 'b t) -> 'b t
              val return : '-> 'a t
              val map : 'a t -> f:('-> 'b) -> 'b t
              val join : 'a t t -> 'a t
              val ignore_m : 'a t -> Monoid.Unit.t t
              val all : 'a t list -> 'a list t
              val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val bind : 'a t -> f:('-> 'b t) -> 'b t
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val both : 'a t -> 'b t -> ('a * 'b) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Syntax :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              module T1 :
                functor (M : Monad->
                  sig
                    type 'a m = 'M.t
                    type 'a t =
                        'Monads.Std.Monad.Fun.T1.m
                        Monads.Std.Monad.Fun.thunk
                    type 'a e = 'Monads.Std.Monad.Fun.T1.m
                  end
              module Make :
                functor (M : Monad->
                  sig
                    val lift : 'M.t -> 'T1(M).t
                    val run : 'T1(M).t -> 'Monads.Std.Monad.Fun.T1.m
                    val void : 'T1(M).t -> Monoid.Unit.t T1(M).t
                    val sequence :
                      Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                    val forever : 'T1(M).t -> 'T1(M).t
                    module Fn :
                      sig
                        val id : '-> 'T1(M).t
                        val ignore : 'T1(M).t -> Monoid.Unit.t T1(M).t
                        val nothing : Monoid.Unit.t -> Monoid.Unit.t T1(M).t
                        val non : ('-> bool T1(M).t) -> '-> bool T1(M).t
                        val apply_n_times :
                          n:Monoid.Int.t ->
                          ('-> 'T1(M).t) -> '-> 'T1(M).t
                        val compose :
                          ('-> 'T1(M).t) ->
                          ('-> 'T1(M).t) -> '-> 'T1(M).t
                      end
                    module Pair :
                      sig
                        val fst : ('a * 'b) T1(M).t -> 'T1(M).t
                        val snd : ('a * 'b) T1(M).t -> 'T1(M).t
                      end
                    module Triple :
                      sig
                        val fst : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                        val snd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                        val trd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                      end
                    module Lift :
                      sig
                        val nullary : '-> 'T1(M).t
                        val unary : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                        val binary :
                          ('-> '-> 'c) ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val ternary :
                          ('-> '-> '-> 'd) ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val quaternary :
                          ('-> '-> '-> '-> 'e) ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val quinary :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                      end
                    module Exn :
                      sig
                        val expect :
                          ?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(M).t) ->
                          f:(Monoid.Unit.t -> 'T1(M).t) ->
                          catch:(exn -> 'T1(M).t) -> 'T1(M).t
                      end
                    module Collection :
                      sig
                        module type S =
                          sig
                            type 'a t
                            val all : 'T1(M).t t -> 'a t T1(M).t
                            val all_ignore :
                              'T1(M).t t -> Monoid.Unit.t T1(M).t
                            val sequence :
                              Monoid.Unit.t T1(M).t t ->
                              Monoid.Unit.t T1(M).t
                            val map :
                              'a t -> f:('-> 'T1(M).t) -> 'b t T1(M).t
                            val iter :
                              'a t ->
                              f:('-> Monoid.Unit.t T1(M).t) ->
                              Monoid.Unit.t T1(M).t
                            val fold :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T1(M).t) -> 'T1(M).t
                            val fold_left :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T1(M).t) -> 'T1(M).t
                            val fold_right :
                              'a t ->
                              f:('-> '-> 'T1(M).t) ->
                              init:'-> 'T1(M).t
                            val reduce :
                              'a t ->
                              f:('-> '-> 'T1(M).t) ->
                              'Option.t T1(M).t
                            val exists :
                              'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                            val for_all :
                              'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                            val count :
                              'a t ->
                              f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b t -> f:('-> 'T1(M).t) -> 'T1(M).t
                            val find :
                              'a t ->
                              f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                            val find_map :
                              'a t ->
                              f:('-> 'Option.t T1(M).t) ->
                              'Option.t T1(M).t
                            val filter :
                              'a t -> f:('-> bool T1(M).t) -> 'a t T1(M).t
                            val filter_map :
                              'a t ->
                              f:('-> 'Option.t T1(M).t) -> 'b t T1(M).t
                          end
                        module Eager :
                          functor (T : Collection.Eager->
                            sig
                              val all : 'T1(M).t T.t -> 'T.t T1(M).t
                              val all_ignore :
                                'T1(M).t T.t -> Monoid.Unit.t T1(M).t
                              val sequence :
                                Monoid.Unit.t T1(M).t T.t ->
                                Monoid.Unit.t T1(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T1(M).t) -> 'T.t T1(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T1(M).t) ->
                                Monoid.Unit.t T1(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(M).t) -> 'T1(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(M).t) -> 'T1(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T1(M).t) ->
                                init:'-> 'T1(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T1(M).t) ->
                                'Option.t T1(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T1(M).t) -> bool T1(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T1(M).t) -> bool T1(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T1(M).t) ->
                                Monoid.Int.t T1(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'Option.t T1(M).t) ->
                                'Option.t T1(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T1(M).t) -> 'T.t T1(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'Option.t T1(M).t) ->
                                'T.t T1(M).t
                            end
                        module Delay :
                          functor (T : Collection.Delay->
                            sig
                              val all : 'T1(M).t T.t -> 'T.t T1(M).t
                              val all_ignore :
                                'T1(M).t T.t -> Monoid.Unit.t T1(M).t
                              val sequence :
                                Monoid.Unit.t T1(M).t T.t ->
                                Monoid.Unit.t T1(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T1(M).t) -> 'T.t T1(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T1(M).t) ->
                                Monoid.Unit.t T1(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(M).t) -> 'T1(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(M).t) -> 'T1(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T1(M).t) ->
                                init:'-> 'T1(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T1(M).t) ->
                                'Option.t T1(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T1(M).t) -> bool T1(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T1(M).t) -> bool T1(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T1(M).t) ->
                                Monoid.Int.t T1(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'Option.t T1(M).t) ->
                                'Option.t T1(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T1(M).t) -> 'T.t T1(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'Option.t T1(M).t) ->
                                'T.t T1(M).t
                            end
                      end
                    module List :
                      sig
                        val all : 'T1(M).t list -> 'a list T1(M).t
                        val all_ignore :
                          'T1(M).t list -> Monoid.Unit.t T1(M).t
                        val sequence :
                          Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                        val map :
                          'a list -> f:('-> 'T1(M).t) -> 'b list T1(M).t
                        val iter :
                          'a list ->
                          f:('-> Monoid.Unit.t T1(M).t) ->
                          Monoid.Unit.t T1(M).t
                        val fold :
                          'a list ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_left :
                          'a list ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_right :
                          'a list ->
                          f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                        val reduce :
                          'a list ->
                          f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                        val exists :
                          'a list -> f:('-> bool T1(M).t) -> bool T1(M).t
                        val for_all :
                          'a list -> f:('-> bool T1(M).t) -> bool T1(M).t
                        val count :
                          'a list ->
                          f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b list -> f:('-> 'T1(M).t) -> 'T1(M).t
                        val find :
                          'a list ->
                          f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                        val find_map :
                          'a list ->
                          f:('-> 'Option.t T1(M).t) ->
                          'Option.t T1(M).t
                        val filter :
                          'a list ->
                          f:('-> bool T1(M).t) -> 'a list T1(M).t
                        val filter_map :
                          'a list ->
                          f:('-> 'Option.t T1(M).t) -> 'b list T1(M).t
                      end
                    module Seq :
                      sig
                        val all :
                          'T1(M).t Core_kernel.Std.Sequence.t ->
                          'Core_kernel.Std.Sequence.t T1(M).t
                        val all_ignore :
                          'T1(M).t Core_kernel.Std.Sequence.t ->
                          Monoid.Unit.t T1(M).t
                        val sequence :
                          Monoid.Unit.t T1(M).t Core_kernel.Std.Sequence.t ->
                          Monoid.Unit.t T1(M).t
                        val map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'T1(M).t) ->
                          'Core_kernel.Std.Sequence.t T1(M).t
                        val iter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> Monoid.Unit.t T1(M).t) ->
                          Monoid.Unit.t T1(M).t
                        val fold :
                          'Core_kernel.Std.Sequence.t ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_left :
                          'Core_kernel.Std.Sequence.t ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_right :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                        val reduce :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                        val exists :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(M).t) -> bool T1(M).t
                        val for_all :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(M).t) -> bool T1(M).t
                        val count :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'T1(M).t) -> 'T1(M).t
                        val find :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                        val find_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'Option.t T1(M).t) ->
                          'Option.t T1(M).t
                        val filter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(M).t) ->
                          'Core_kernel.Std.Sequence.t T1(M).t
                        val filter_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'Option.t T1(M).t) ->
                          'Core_kernel.Std.Sequence.t T1(M).t
                      end
                    val ( >=> ) :
                      ('-> 'T1(M).t) ->
                      ('-> 'T1(M).t) -> '-> 'T1(M).t
                    val ( !! ) : '-> 'T1(M).t
                    val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(M).t ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( >>= ) :
                      'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                    val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                        val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                      end
                    val bind :
                      'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
                    val return : '-> 'T1(M).t
                    val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                    val join : 'T1(M).t T1(M).t -> 'T1(M).t
                    val ignore_m : 'T1(M).t -> Monoid.Unit.t T1(M).t
                    val all : 'T1(M).t list -> 'a list T1(M).t
                    val all_ignore :
                      Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T1(M).t
                        val ( >>= ) :
                          'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                        val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                        module Let_syntax :
                          sig
                            val return : '-> 'T1(M).t
                            val bind :
                              'T1(M).t ->
                              f:('-> 'T1(M).t) -> 'T1(M).t
                            val map :
                              'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                            val both :
                              'T1(M).t -> 'T1(M).t -> ('a * 'b) T1(M).t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Syntax :
                      sig
                        val ( >>= ) :
                          'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                        val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                        val ( >=> ) :
                          ('-> 'T1(M).t) ->
                          ('-> 'T1(M).t) -> '-> 'T1(M).t
                        val ( !! ) : '-> 'T1(M).t
                        val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                      end
                  end
              module T2 :
                functor (M : Monad2->
                  sig
                    type ('a, 'e) m = ('a, 'e) M.t
                    type ('a, 'e) t =
                        ('a, 'e) Monads.Std.Monad.Fun.T2.m
                        Monads.Std.Monad.Fun.thunk
                    type ('a, 'e) e = ('a, 'e) Monads.Std.Monad.Fun.T2.m
                  end
              module Make2 :
                functor (M : Monad2->
                  sig
                    val lift : ('a, 'e) M.t -> ('a, 'e) T2(M).t
                    val run :
                      ('a, 'e) T2(M).t -> ('a, 'e) Monads.Std.Monad.Fun.T2.m
                    val void :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    module Fn :
                      sig
                        val id : '-> ('a, 'e) T2(M).t
                        val ignore :
                          ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                        val nothing :
                          Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
                        val non :
                          ('-> (bool, 'e) T2(M).t) ->
                          '-> (bool, 'e) T2(M).t
                        val apply_n_times :
                          n:Monoid.Int.t ->
                          ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                        val compose :
                          ('-> ('c, 'e) T2(M).t) ->
                          ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                      end
                    module Pair :
                      sig
                        val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                        val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
                      end
                    module Triple :
                      sig
                        val fst :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                        val snd :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val trd :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
                      end
                    module Lift :
                      sig
                        val nullary : '-> ('a, 'e) T2(M).t
                        val unary :
                          ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val binary :
                          ('-> '-> 'c) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                        val ternary :
                          ('-> '-> '-> 'd) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t ->
                          ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                        val quaternary :
                          ('-> '-> '-> '-> 'e) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                        val quinary :
                          ('-> '-> '-> '-> '-> 'f) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t ->
                          ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                      end
                    module Exn :
                      sig
                        val expect :
                          ?finally:(Monoid.Unit.t ->
                                    (Monoid.Unit.t, 's) T2(M).t) ->
                          f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
                          catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
                      end
                    module Collection :
                      sig
                        module type S =
                          sig
                            type 'a t
                            val all :
                              ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                            val all_ignore :
                              ('a, 'e) T2(M).t t ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val sequence :
                              (Monoid.Unit.t, 'e) T2(M).t t ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val map :
                              'a t ->
                              f:('-> ('b, 'e) T2(M).t) ->
                              ('b t, 'e) T2(M).t
                            val iter :
                              'a t ->
                              f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val fold :
                              'a t ->
                              init:'->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              ('b, 'e) T2(M).t
                            val fold_left :
                              'a t ->
                              init:'->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              ('b, 'e) T2(M).t
                            val fold_right :
                              'a t ->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              init:'-> ('b, 'e) T2(M).t
                            val reduce :
                              'a t ->
                              f:('-> '-> ('a, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val exists :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (bool, 'e) T2(M).t
                            val for_all :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (bool, 'e) T2(M).t
                            val count :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (Monoid.Int.t, 'e) T2(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b t ->
                              f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                            val find :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val find_map :
                              'a t ->
                              f:('-> ('Option.t, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val filter :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              ('a t, 'e) T2(M).t
                            val filter_map :
                              'a t ->
                              f:('-> ('Option.t, 'e) T2(M).t) ->
                              ('b t, 'e) T2(M).t
                          end
                        module Eager :
                          functor (T : Collection.Eager->
                            sig
                              val all :
                                ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                              val all_ignore :
                                ('a, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val sequence :
                                (Monoid.Unit.t, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val map :
                                'T.t ->
                                f:('-> ('b, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val iter :
                                'T.t ->
                                f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                init:'-> ('b, 'e) T2(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> ('a, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val exists :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val for_all :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val count :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (Monoid.Int.t, 'e) T2(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> ('a, 'e) T2(M).t) ->
                                ('a, 'e) T2(M).t
                              val find :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val find_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val filter :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                            end
                        module Delay :
                          functor (T : Collection.Delay->
                            sig
                              val all :
                                ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                              val all_ignore :
                                ('a, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val sequence :
                                (Monoid.Unit.t, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val map :
                                'T.t ->
                                f:('-> ('b, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val iter :
                                'T.t ->
                                f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                init:'-> ('b, 'e) T2(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> ('a, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val exists :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val for_all :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val count :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (Monoid.Int.t, 'e) T2(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> ('a, 'e) T2(M).t) ->
                                ('a, 'e) T2(M).t
                              val find :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val find_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val filter :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                            end
                      end
                    module List :
                      sig
                        val all :
                          ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t list ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t list ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'a list ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                        val iter :
                          'a list ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'a list ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'a list ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'a list ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'a list ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b list ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'a list ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('a list, 'e) T2(M).t
                        val filter_map :
                          'a list ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('b list, 'e) T2(M).t
                      end
                    module Seq :
                      sig
                        val all :
                          ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t
                          Core_kernel.Std.Sequence.t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('b, 'e) T2(M).t) ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                        val iter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'Core_kernel.Std.Sequence.t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'Core_kernel.Std.Sequence.t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                        val filter_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                      end
                    val ( >=> ) :
                      ('-> ('b, 'e) T2(M).t) ->
                      ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                    val ( !! ) : '-> ('a, 'e) T2(M).t
                    val ( !$ ) :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) T2(M).t
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                        module Let_syntax :
                          sig
                            val return : '-> ('a, 'b) T2(M).t
                            val bind :
                              ('a, 'e) T2(M).t ->
                              f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                            val map :
                              ('a, 'e) T2(M).t ->
                              f:('-> 'b) -> ('b, 'e) T2(M).t
                            val both :
                              ('a, 'e) T2(M).t ->
                              ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                      end
                    val bind :
                      ('a, 'e) T2(M).t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val return : '-> ('a, 'b) T2(M).t
                    val map :
                      ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                    val join :
                      (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val ignore_m :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                    val all_ignore :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    module Syntax :
                      sig
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                        val ( >=> ) :
                          ('-> ('b, 'e) T2(M).t) ->
                          ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                        val ( !! ) : '-> ('a, 'e) T2(M).t
                        val ( !$ ) :
                          ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t ->
                          ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t ->
                          ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                      end
                  end
            end
          module Lazy :
            sig
              module type S =
                sig
                  type 'a t
                  type 'a m
                  type 'a e
                  val lift : 'a m -> 'a t
                  val run : 'a t -> 'a e
                  val void : 'a t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
                  val forever : 'a t -> 'b t
                  module Fn :
                    sig
                      val id : '-> 'a t
                      val ignore : 'a t -> Monoid.Unit.t t
                      val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                      val non : ('-> bool t) -> '-> bool t
                      val apply_n_times :
                        n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                      val compose :
                        ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                    end
                  module Pair :
                    sig
                      val fst : ('a * 'b) t -> 'a t
                      val snd : ('a * 'b) t -> 'b t
                    end
                  module Triple :
                    sig
                      val fst : ('a * 'b * 'c) t -> 'a t
                      val snd : ('a * 'b * 'c) t -> 'b t
                      val trd : ('a * 'b * 'c) t -> 'c t
                    end
                  module Lift :
                    sig
                      val nullary : '-> 'a t
                      val unary : ('-> 'b) -> 'a t -> 'b t
                      val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ternary :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val quaternary :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val quinary :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                  module Exn :
                    sig
                      val expect :
                        ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                        f:(Monoid.Unit.t -> 'a t) ->
                        catch:(exn -> 'a t) -> 'a t
                    end
                  module Collection :
                    sig
                      module type S =
                        sig
                          type 'a t
                          val all : 'a t t -> 'a t t
                          val all_ignore : 'a t t -> Monoid.Unit.t t
                          val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                          val map : 'a t -> f:('-> 'b t) -> 'b t t
                          val iter :
                            'a t ->
                            f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                          val fold :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_left :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_right :
                            'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                          val reduce :
                            'a t -> f:('-> '-> 'a t) -> 'Option.t t
                          val exists : 'a t -> f:('-> bool t) -> bool t
                          val for_all : 'a t -> f:('-> bool t) -> bool t
                          val count :
                            'a t -> f:('-> bool t) -> Monoid.Int.t t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b t -> f:('-> 'a t) -> 'a t
                          val find :
                            'a t -> f:('-> bool t) -> 'Option.t t
                          val find_map :
                            'a t -> f:('-> 'Option.t t) -> 'Option.t t
                          val filter : 'a t -> f:('-> bool t) -> 'a t t
                          val filter_map :
                            'a t -> f:('-> 'Option.t t) -> 'b t t
                        end
                      module Eager :
                        functor (T : Collection.Eager->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'Option.t t
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t t) -> 'Option.t t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'Option.t t) -> 'T.t t
                          end
                      module Delay :
                        functor (T : Collection.Delay->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'Option.t t
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t t) -> 'Option.t t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'Option.t t) -> 'T.t t
                          end
                    end
                  module List :
                    sig
                      val all : 'a t List.t -> 'List.t t
                      val all_ignore : 'a t List.t -> Monoid.Unit.t t
                      val sequence :
                        Monoid.Unit.t t List.t -> Monoid.Unit.t t
                      val map : 'List.t -> f:('-> 'b t) -> 'List.t t
                      val iter :
                        'List.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'List.t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'List.t -> f:('-> bool t) -> bool t
                      val for_all : 'List.t -> f:('-> bool t) -> bool t
                      val count :
                        'List.t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'List.t -> f:('-> 'a t) -> 'a t
                      val find :
                        'List.t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'List.t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter :
                        'List.t -> f:('-> bool t) -> 'List.t t
                      val filter_map :
                        'List.t -> f:('-> 'Option.t t) -> 'List.t t
                    end
                  module Seq :
                    sig
                      val all : 'a t Seq.t -> 'Seq.t t
                      val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
                      val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
                      val iter :
                        'Seq.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'Seq.t -> f:('-> bool t) -> bool t
                      val for_all : 'Seq.t -> f:('-> bool t) -> bool t
                      val count :
                        'Seq.t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'Seq.t -> f:('-> 'a t) -> 'a t
                      val find :
                        'Seq.t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
                      val filter_map :
                        'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
                    end
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Monad_infix :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                    end
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val return : '-> 'a t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val join : 'a t t -> 'a t
                  val ignore_m : 'a t -> Monoid.Unit.t t
                  val all : 'a t list -> 'a list t
                  val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      module Let_syntax :
                        sig
                          val return : '-> 'a t
                          val bind : 'a t -> f:('-> 'b t) -> 'b t
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val both : 'a t -> 'b t -> ('a * 'b) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Syntax :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      val ( >=> ) :
                        ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                      val ( !! ) : '-> 'a t
                      val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                      val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                end
              module type S2 =
                sig
                  type ('a, 'e) t
                  type ('a, 'e) m
                  type ('a, 'e) e
                  val lift : ('a, 'e) m -> ('a, 'e) t
                  val run : ('a, 'e) t -> ('a, 'e) e
                  val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val forever : ('a, 'e) t -> ('b, 'e) t
                  module Fn :
                    sig
                      val id : '-> ('a, 'e) t
                      val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                      val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                      val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                      val apply_n_times :
                        n:Monoid.Int.t ->
                        ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                      val compose :
                        ('-> ('c, 'e) t) ->
                        ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                    end
                  module Pair :
                    sig
                      val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                      val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                    end
                  module Triple :
                    sig
                      val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                      val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                      val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                    end
                  module Lift :
                    sig
                      val nullary : '-> ('a, 'e) t
                      val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                      val binary :
                        ('-> '-> 'c) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                      val ternary :
                        ('-> '-> '-> 'd) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                      val quaternary :
                        ('-> '-> '-> '-> 'e) ->
                        ('a, 's) t ->
                        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                      val quinary :
                        ('-> '-> '-> '-> '-> 'f) ->
                        ('a, 's) t ->
                        ('b, 's) t ->
                        ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                    end
                  module Exn :
                    sig
                      val expect :
                        ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                        f:(Monoid.Unit.t -> ('a, 's) t) ->
                        catch:(exn -> ('a, 's) t) -> ('a, 's) t
                    end
                  module Collection :
                    sig
                      module type S =
                        sig
                          type 'a t
                          val all : ('a, 'e) t t -> ('a t, 'e) t
                          val all_ignore :
                            ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
                          val sequence :
                            (Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
                          val map :
                            'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                          val iter :
                            'a t ->
                            f:('-> (Monoid.Unit.t, 'e) t) ->
                            (Monoid.Unit.t, 'e) t
                          val fold :
                            'a t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_left :
                            'a t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_right :
                            'a t ->
                            f:('-> '-> ('b, 'e) t) ->
                            init:'-> ('b, 'e) t
                          val reduce :
                            'a t ->
                            f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                          val exists :
                            'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val for_all :
                            'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val count :
                            'a t ->
                            f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                          val find :
                            'a t ->
                            f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                          val find_map :
                            'a t ->
                            f:('-> ('Option.t, 'e) t) ->
                            ('Option.t, 'e) t
                          val filter :
                            'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                          val filter_map :
                            'a t ->
                            f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                        end
                      module Eager :
                        functor (T : Collection.Eager->
                          sig
                            val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                            val all_ignore :
                              ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                            val sequence :
                              (Monoid.Unit.t, 'e) t T.t ->
                              (Monoid.Unit.t, 'e) t
                            val map :
                              'T.t ->
                              f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                            val iter :
                              'T.t ->
                              f:('-> (Monoid.Unit.t, 'e) t) ->
                              (Monoid.Unit.t, 'e) t
                            val fold :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_left :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> ('b, 'e) t) ->
                              init:'-> ('b, 'e) t
                            val reduce :
                              'T.t ->
                              f:('-> '-> ('a, 'e) t) ->
                              ('Option.t, 'e) t
                            val exists :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val for_all :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val count :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                            val find :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                            val find_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) ->
                              ('Option.t, 'e) t
                            val filter :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                            val filter_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                          end
                      module Delay :
                        functor (T : Collection.Delay->
                          sig
                            val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                            val all_ignore :
                              ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                            val sequence :
                              (Monoid.Unit.t, 'e) t T.t ->
                              (Monoid.Unit.t, 'e) t
                            val map :
                              'T.t ->
                              f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                            val iter :
                              'T.t ->
                              f:('-> (Monoid.Unit.t, 'e) t) ->
                              (Monoid.Unit.t, 'e) t
                            val fold :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_left :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> ('b, 'e) t) ->
                              init:'-> ('b, 'e) t
                            val reduce :
                              'T.t ->
                              f:('-> '-> ('a, 'e) t) ->
                              ('Option.t, 'e) t
                            val exists :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val for_all :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val count :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                            val find :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                            val find_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) ->
                              ('Option.t, 'e) t
                            val filter :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                            val filter_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                          end
                    end
                  module List :
                    sig
                      val all : ('a, 'e) t List.t -> ('List.t, 'e) t
                      val all_ignore :
                        ('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                      val map :
                        'List.t ->
                        f:('-> ('b, 'e) t) -> ('List.t, 'e) t
                      val iter :
                        'List.t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'List.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'List.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'List.t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'List.t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'List.t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'List.t ->
                        f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'List.t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'List.t ->
                        f:('-> (bool, 'e) t) -> ('List.t, 'e) t
                      val filter_map :
                        'List.t ->
                        f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
                    end
                  module Seq :
                    sig
                      val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
                      val all_ignore :
                        ('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                      val map :
                        'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
                      val iter :
                        'Seq.t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'Seq.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'Seq.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'Seq.t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'Seq.t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'Seq.t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'Seq.t ->
                        f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'Seq.t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'Seq.t ->
                        f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
                      val filter_map :
                        'Seq.t ->
                        f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
                    end
                  val ( >=> ) :
                    ('-> ('b, 'e) t) ->
                    ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                  val ( !! ) : '-> ('a, 'e) t
                  val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      module Let_syntax :
                        sig
                          val return : '-> ('a, 'b) t
                          val bind :
                            ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                          val both :
                            ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Monad_infix :
                    sig
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                    end
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val return : '-> ('a, 'b) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                  val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val all : ('a, 'e) t list -> ('a list, 'e) t
                  val all_ignore :
                    (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                  module Syntax :
                    sig
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      val ( >=> ) :
                        ('-> ('b, 'e) t) ->
                        ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                      val ( !! ) : '-> ('a, 'e) t
                      val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                      val ( !$$ ) :
                        ('-> '-> 'c) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        ('a, 's) t ->
                        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        ('a, 's) t ->
                        ('b, 's) t ->
                        ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                    end
                end
              type 'a t = 'Core_kernel.Std.Lazy.t
              type 'a m = 'a
              type 'a e = 'a
              val lift : '-> 'a t
              val run : 'a t -> 'a
              val void : 'a t -> Monoid.Unit.t t
              val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
              val forever : 'a t -> 'b t
              module Fn :
                sig
                  val id : '-> 'a t
                  val ignore : 'a t -> Monoid.Unit.t t
                  val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                  val non : ('-> bool t) -> '-> bool t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                  val compose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                end
              module Pair :
                sig
                  val fst : ('a * 'b) t -> 'a t
                  val snd : ('a * 'b) t -> 'b t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c) t -> 'a t
                  val snd : ('a * 'b * 'c) t -> 'b t
                  val trd : ('a * 'b * 'c) t -> 'c t
                end
              module Lift :
                sig
                  val nullary : '-> 'a t
                  val unary : ('-> 'b) -> 'a t -> 'b t
                  val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ternary :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                    f:(Monoid.Unit.t -> 'a t) -> catch:(exn -> 'a t) -> 'a t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all :
                        'Core_kernel.Std.Lazy.t t ->
                        'a t Core_kernel.Std.Lazy.t
                      val all_ignore :
                        'Core_kernel.Std.Lazy.t t ->
                        Monoid.Unit.t Core_kernel.Std.Lazy.t
                      val sequence :
                        Monoid.Unit.t Core_kernel.Std.Lazy.t t ->
                        Monoid.Unit.t Core_kernel.Std.Lazy.t
                      val map :
                        'a t ->
                        f:('-> 'Core_kernel.Std.Lazy.t) ->
                        'b t Core_kernel.Std.Lazy.t
                      val iter :
                        'a t ->
                        f:('-> Monoid.Unit.t Core_kernel.Std.Lazy.t) ->
                        Monoid.Unit.t Core_kernel.Std.Lazy.t
                      val fold :
                        'a t ->
                        init:'->
                        f:('-> '-> 'Core_kernel.Std.Lazy.t) ->
                        'Core_kernel.Std.Lazy.t
                      val fold_left :
                        'a t ->
                        init:'->
                        f:('-> '-> 'Core_kernel.Std.Lazy.t) ->
                        'Core_kernel.Std.Lazy.t
                      val fold_right :
                        'a t ->
                        f:('-> '-> 'Core_kernel.Std.Lazy.t) ->
                        init:'-> 'Core_kernel.Std.Lazy.t
                      val reduce :
                        'a t ->
                        f:('-> '-> 'Core_kernel.Std.Lazy.t) ->
                        'Option.t Core_kernel.Std.Lazy.t
                      val exists :
                        'a t ->
                        f:('-> bool Core_kernel.Std.Lazy.t) ->
                        bool Core_kernel.Std.Lazy.t
                      val for_all :
                        'a t ->
                        f:('-> bool Core_kernel.Std.Lazy.t) ->
                        bool Core_kernel.Std.Lazy.t
                      val count :
                        'a t ->
                        f:('-> bool Core_kernel.Std.Lazy.t) ->
                        Monoid.Int.t Core_kernel.Std.Lazy.t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t ->
                        f:('-> 'Core_kernel.Std.Lazy.t) ->
                        'Core_kernel.Std.Lazy.t
                      val find :
                        'a t ->
                        f:('-> bool Core_kernel.Std.Lazy.t) ->
                        'Option.t Core_kernel.Std.Lazy.t
                      val find_map :
                        'a t ->
                        f:('-> 'Option.t Core_kernel.Std.Lazy.t) ->
                        'Option.t Core_kernel.Std.Lazy.t
                      val filter :
                        'a t ->
                        f:('-> bool Core_kernel.Std.Lazy.t) ->
                        'a t Core_kernel.Std.Lazy.t
                      val filter_map :
                        'a t ->
                        f:('-> 'Option.t Core_kernel.Std.Lazy.t) ->
                        'b t Core_kernel.Std.Lazy.t
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : 'a t T.t -> 'T.t t
                        val all_ignore : 'a t T.t -> Monoid.Unit.t t
                        val sequence : Monoid.Unit.t t T.t -> Monoid.Unit.t t
                        val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                        val iter :
                          'T.t ->
                          f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                        val fold :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_left :
                          'T.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                        val fold_right :
                          'T.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                        val reduce :
                          'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                        val exists : 'T.t -> f:('-> bool t) -> bool t
                        val for_all : 'T.t -> f:('-> bool t) -> bool t
                        val count :
                          'T.t -> f:('-> bool t) -> Monoid.Int.t t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> 'a t) -> 'a t
                        val find :
                          'T.t -> f:('-> bool t) -> 'Option.t t
                        val find_map :
                          'T.t -> f:('-> 'Option.t t) -> 'Option.t t
                        val filter : 'T.t -> f:('-> bool t) -> 'T.t t
                        val filter_map :
                          'T.t -> f:('-> 'Option.t t) -> 'T.t t
                      end
                end
              module List :
                sig
                  val all : 'a t List.t -> 'List.t t
                  val all_ignore : 'a t List.t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
                  val map : 'List.t -> f:('-> 'b t) -> 'List.t t
                  val iter :
                    'List.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'List.t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'List.t -> f:('-> bool t) -> bool t
                  val for_all : 'List.t -> f:('-> bool t) -> bool t
                  val count : 'List.t -> f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'List.t -> f:('-> 'a t) -> 'a t
                  val find : 'List.t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'List.t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'List.t -> f:('-> bool t) -> 'List.t t
                  val filter_map :
                    'List.t -> f:('-> 'Option.t t) -> 'List.t t
                end
              module Seq :
                sig
                  val all : 'a t Seq.t -> 'Seq.t t
                  val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
                  val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
                  val iter :
                    'Seq.t -> f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                  val fold :
                    'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_left :
                    'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                  val fold_right :
                    'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                  val reduce :
                    'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
                  val exists : 'Seq.t -> f:('-> bool t) -> bool t
                  val for_all : 'Seq.t -> f:('-> bool t) -> bool t
                  val count : 'Seq.t -> f:('-> bool t) -> Monoid.Int.t t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Seq.t -> f:('-> 'a t) -> 'a t
                  val find : 'Seq.t -> f:('-> bool t) -> 'Option.t t
                  val find_map :
                    'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
                  val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
                  val filter_map :
                    'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
                end
              val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
              val ( !! ) : '-> 'a t
              val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
              val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
              val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
              val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
              module Monad_infix :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                end
              val bind : 'a t -> f:('-> 'b t) -> 'b t
              val return : '-> 'a t
              val map : 'a t -> f:('-> 'b) -> 'b t
              val join : 'a t t -> 'a t
              val ignore_m : 'a t -> Monoid.Unit.t t
              val all : 'a t list -> 'a list t
              val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
              module Let_syntax :
                sig
                  val return : '-> 'a t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val bind : 'a t -> f:('-> 'b t) -> 'b t
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val both : 'a t -> 'b t -> ('a * 'b) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Syntax :
                sig
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                end
              module T1 :
                functor (M : Monad->
                  sig
                    type 'a m = 'M.t
                    type 'a t =
                        'Monads.Std.Monad.Lazy.T1.m Core_kernel.Std.Lazy.t
                    type 'a e = 'Monads.Std.Monad.Lazy.T1.m
                  end
              module Make :
                functor (M : Monad->
                  sig
                    val lift : 'M.t -> 'T1(M).t
                    val run : 'T1(M).t -> 'Monads.Std.Monad.Lazy.T1.m
                    val void : 'T1(M).t -> Monoid.Unit.t T1(M).t
                    val sequence :
                      Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                    val forever : 'T1(M).t -> 'T1(M).t
                    module Fn :
                      sig
                        val id : '-> 'T1(M).t
                        val ignore : 'T1(M).t -> Monoid.Unit.t T1(M).t
                        val nothing : Monoid.Unit.t -> Monoid.Unit.t T1(M).t
                        val non : ('-> bool T1(M).t) -> '-> bool T1(M).t
                        val apply_n_times :
                          n:Monoid.Int.t ->
                          ('-> 'T1(M).t) -> '-> 'T1(M).t
                        val compose :
                          ('-> 'T1(M).t) ->
                          ('-> 'T1(M).t) -> '-> 'T1(M).t
                      end
                    module Pair :
                      sig
                        val fst : ('a * 'b) T1(M).t -> 'T1(M).t
                        val snd : ('a * 'b) T1(M).t -> 'T1(M).t
                      end
                    module Triple :
                      sig
                        val fst : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                        val snd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                        val trd : ('a * 'b * 'c) T1(M).t -> 'T1(M).t
                      end
                    module Lift :
                      sig
                        val nullary : '-> 'T1(M).t
                        val unary : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                        val binary :
                          ('-> '-> 'c) ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val ternary :
                          ('-> '-> '-> 'd) ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val quaternary :
                          ('-> '-> '-> '-> 'e) ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val quinary :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                      end
                    module Exn :
                      sig
                        val expect :
                          ?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(M).t) ->
                          f:(Monoid.Unit.t -> 'T1(M).t) ->
                          catch:(exn -> 'T1(M).t) -> 'T1(M).t
                      end
                    module Collection :
                      sig
                        module type S =
                          sig
                            type 'a t
                            val all : 'T1(M).t t -> 'a t T1(M).t
                            val all_ignore :
                              'T1(M).t t -> Monoid.Unit.t T1(M).t
                            val sequence :
                              Monoid.Unit.t T1(M).t t ->
                              Monoid.Unit.t T1(M).t
                            val map :
                              'a t -> f:('-> 'T1(M).t) -> 'b t T1(M).t
                            val iter :
                              'a t ->
                              f:('-> Monoid.Unit.t T1(M).t) ->
                              Monoid.Unit.t T1(M).t
                            val fold :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T1(M).t) -> 'T1(M).t
                            val fold_left :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T1(M).t) -> 'T1(M).t
                            val fold_right :
                              'a t ->
                              f:('-> '-> 'T1(M).t) ->
                              init:'-> 'T1(M).t
                            val reduce :
                              'a t ->
                              f:('-> '-> 'T1(M).t) ->
                              'Option.t T1(M).t
                            val exists :
                              'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                            val for_all :
                              'a t -> f:('-> bool T1(M).t) -> bool T1(M).t
                            val count :
                              'a t ->
                              f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b t -> f:('-> 'T1(M).t) -> 'T1(M).t
                            val find :
                              'a t ->
                              f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                            val find_map :
                              'a t ->
                              f:('-> 'Option.t T1(M).t) ->
                              'Option.t T1(M).t
                            val filter :
                              'a t -> f:('-> bool T1(M).t) -> 'a t T1(M).t
                            val filter_map :
                              'a t ->
                              f:('-> 'Option.t T1(M).t) -> 'b t T1(M).t
                          end
                        module Eager :
                          functor (T : Collection.Eager->
                            sig
                              val all : 'T1(M).t T.t -> 'T.t T1(M).t
                              val all_ignore :
                                'T1(M).t T.t -> Monoid.Unit.t T1(M).t
                              val sequence :
                                Monoid.Unit.t T1(M).t T.t ->
                                Monoid.Unit.t T1(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T1(M).t) -> 'T.t T1(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T1(M).t) ->
                                Monoid.Unit.t T1(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(M).t) -> 'T1(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(M).t) -> 'T1(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T1(M).t) ->
                                init:'-> 'T1(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T1(M).t) ->
                                'Option.t T1(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T1(M).t) -> bool T1(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T1(M).t) -> bool T1(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T1(M).t) ->
                                Monoid.Int.t T1(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'Option.t T1(M).t) ->
                                'Option.t T1(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T1(M).t) -> 'T.t T1(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'Option.t T1(M).t) ->
                                'T.t T1(M).t
                            end
                        module Delay :
                          functor (T : Collection.Delay->
                            sig
                              val all : 'T1(M).t T.t -> 'T.t T1(M).t
                              val all_ignore :
                                'T1(M).t T.t -> Monoid.Unit.t T1(M).t
                              val sequence :
                                Monoid.Unit.t T1(M).t T.t ->
                                Monoid.Unit.t T1(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T1(M).t) -> 'T.t T1(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T1(M).t) ->
                                Monoid.Unit.t T1(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(M).t) -> 'T1(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(M).t) -> 'T1(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T1(M).t) ->
                                init:'-> 'T1(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T1(M).t) ->
                                'Option.t T1(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T1(M).t) -> bool T1(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T1(M).t) -> bool T1(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T1(M).t) ->
                                Monoid.Int.t T1(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t -> f:('-> 'T1(M).t) -> 'T1(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'Option.t T1(M).t) ->
                                'Option.t T1(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T1(M).t) -> 'T.t T1(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'Option.t T1(M).t) ->
                                'T.t T1(M).t
                            end
                      end
                    module List :
                      sig
                        val all : 'T1(M).t list -> 'a list T1(M).t
                        val all_ignore :
                          'T1(M).t list -> Monoid.Unit.t T1(M).t
                        val sequence :
                          Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                        val map :
                          'a list -> f:('-> 'T1(M).t) -> 'b list T1(M).t
                        val iter :
                          'a list ->
                          f:('-> Monoid.Unit.t T1(M).t) ->
                          Monoid.Unit.t T1(M).t
                        val fold :
                          'a list ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_left :
                          'a list ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_right :
                          'a list ->
                          f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                        val reduce :
                          'a list ->
                          f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                        val exists :
                          'a list -> f:('-> bool T1(M).t) -> bool T1(M).t
                        val for_all :
                          'a list -> f:('-> bool T1(M).t) -> bool T1(M).t
                        val count :
                          'a list ->
                          f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b list -> f:('-> 'T1(M).t) -> 'T1(M).t
                        val find :
                          'a list ->
                          f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                        val find_map :
                          'a list ->
                          f:('-> 'Option.t T1(M).t) ->
                          'Option.t T1(M).t
                        val filter :
                          'a list ->
                          f:('-> bool T1(M).t) -> 'a list T1(M).t
                        val filter_map :
                          'a list ->
                          f:('-> 'Option.t T1(M).t) -> 'b list T1(M).t
                      end
                    module Seq :
                      sig
                        val all :
                          'T1(M).t Core_kernel.Std.Sequence.t ->
                          'Core_kernel.Std.Sequence.t T1(M).t
                        val all_ignore :
                          'T1(M).t Core_kernel.Std.Sequence.t ->
                          Monoid.Unit.t T1(M).t
                        val sequence :
                          Monoid.Unit.t T1(M).t Core_kernel.Std.Sequence.t ->
                          Monoid.Unit.t T1(M).t
                        val map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'T1(M).t) ->
                          'Core_kernel.Std.Sequence.t T1(M).t
                        val iter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> Monoid.Unit.t T1(M).t) ->
                          Monoid.Unit.t T1(M).t
                        val fold :
                          'Core_kernel.Std.Sequence.t ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_left :
                          'Core_kernel.Std.Sequence.t ->
                          init:'-> f:('-> '-> 'T1(M).t) -> 'T1(M).t
                        val fold_right :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> 'T1(M).t) -> init:'-> 'T1(M).t
                        val reduce :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> 'T1(M).t) -> 'Option.t T1(M).t
                        val exists :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(M).t) -> bool T1(M).t
                        val for_all :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(M).t) -> bool T1(M).t
                        val count :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(M).t) -> Monoid.Int.t T1(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'T1(M).t) -> 'T1(M).t
                        val find :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(M).t) -> 'Option.t T1(M).t
                        val find_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'Option.t T1(M).t) ->
                          'Option.t T1(M).t
                        val filter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(M).t) ->
                          'Core_kernel.Std.Sequence.t T1(M).t
                        val filter_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'Option.t T1(M).t) ->
                          'Core_kernel.Std.Sequence.t T1(M).t
                      end
                    val ( >=> ) :
                      ('-> 'T1(M).t) ->
                      ('-> 'T1(M).t) -> '-> 'T1(M).t
                    val ( !! ) : '-> 'T1(M).t
                    val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(M).t ->
                      'T1(M).t ->
                      'T1(M).t -> 'T1(M).t -> 'T1(M).t -> 'T1(M).t
                    val ( >>= ) :
                      'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                    val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                        val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                      end
                    val bind :
                      'T1(M).t -> f:('-> 'T1(M).t) -> 'T1(M).t
                    val return : '-> 'T1(M).t
                    val map : 'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                    val join : 'T1(M).t T1(M).t -> 'T1(M).t
                    val ignore_m : 'T1(M).t -> Monoid.Unit.t T1(M).t
                    val all : 'T1(M).t list -> 'a list T1(M).t
                    val all_ignore :
                      Monoid.Unit.t T1(M).t list -> Monoid.Unit.t T1(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T1(M).t
                        val ( >>= ) :
                          'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                        val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                        module Let_syntax :
                          sig
                            val return : '-> 'T1(M).t
                            val bind :
                              'T1(M).t ->
                              f:('-> 'T1(M).t) -> 'T1(M).t
                            val map :
                              'T1(M).t -> f:('-> 'b) -> 'T1(M).t
                            val both :
                              'T1(M).t -> 'T1(M).t -> ('a * 'b) T1(M).t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Syntax :
                      sig
                        val ( >>= ) :
                          'T1(M).t -> ('-> 'T1(M).t) -> 'T1(M).t
                        val ( >>| ) : 'T1(M).t -> ('-> 'b) -> 'T1(M).t
                        val ( >=> ) :
                          ('-> 'T1(M).t) ->
                          ('-> 'T1(M).t) -> '-> 'T1(M).t
                        val ( !! ) : '-> 'T1(M).t
                        val ( !$ ) : ('-> 'b) -> 'T1(M).t -> 'T1(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t ->
                          'T1(M).t -> 'T1(M).t -> 'T1(M).t
                      end
                  end
              module T2 :
                functor (M : Monad2->
                  sig
                    type ('a, 'e) m = ('a, 'e) M.t
                    type ('a, 'e) t =
                        ('a, 'e) Monads.Std.Monad.Lazy.T2.m
                        Core_kernel.Std.Lazy.t
                    type ('a, 'e) e = ('a, 'e) Monads.Std.Monad.Lazy.T2.m
                  end
              module Make2 :
                functor (M : Monad2->
                  sig
                    val lift : ('a, 'e) M.t -> ('a, 'e) T2(M).t
                    val run :
                      ('a, 'e) T2(M).t -> ('a, 'e) Monads.Std.Monad.Lazy.T2.m
                    val void :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    module Fn :
                      sig
                        val id : '-> ('a, 'e) T2(M).t
                        val ignore :
                          ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                        val nothing :
                          Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
                        val non :
                          ('-> (bool, 'e) T2(M).t) ->
                          '-> (bool, 'e) T2(M).t
                        val apply_n_times :
                          n:Monoid.Int.t ->
                          ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                        val compose :
                          ('-> ('c, 'e) T2(M).t) ->
                          ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                      end
                    module Pair :
                      sig
                        val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                        val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
                      end
                    module Triple :
                      sig
                        val fst :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                        val snd :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val trd :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
                      end
                    module Lift :
                      sig
                        val nullary : '-> ('a, 'e) T2(M).t
                        val unary :
                          ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val binary :
                          ('-> '-> 'c) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                        val ternary :
                          ('-> '-> '-> 'd) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t ->
                          ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                        val quaternary :
                          ('-> '-> '-> '-> 'e) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                        val quinary :
                          ('-> '-> '-> '-> '-> 'f) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t ->
                          ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                      end
                    module Exn :
                      sig
                        val expect :
                          ?finally:(Monoid.Unit.t ->
                                    (Monoid.Unit.t, 's) T2(M).t) ->
                          f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
                          catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
                      end
                    module Collection :
                      sig
                        module type S =
                          sig
                            type 'a t
                            val all :
                              ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                            val all_ignore :
                              ('a, 'e) T2(M).t t ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val sequence :
                              (Monoid.Unit.t, 'e) T2(M).t t ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val map :
                              'a t ->
                              f:('-> ('b, 'e) T2(M).t) ->
                              ('b t, 'e) T2(M).t
                            val iter :
                              'a t ->
                              f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val fold :
                              'a t ->
                              init:'->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              ('b, 'e) T2(M).t
                            val fold_left :
                              'a t ->
                              init:'->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              ('b, 'e) T2(M).t
                            val fold_right :
                              'a t ->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              init:'-> ('b, 'e) T2(M).t
                            val reduce :
                              'a t ->
                              f:('-> '-> ('a, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val exists :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (bool, 'e) T2(M).t
                            val for_all :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (bool, 'e) T2(M).t
                            val count :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (Monoid.Int.t, 'e) T2(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b t ->
                              f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                            val find :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val find_map :
                              'a t ->
                              f:('-> ('Option.t, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val filter :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              ('a t, 'e) T2(M).t
                            val filter_map :
                              'a t ->
                              f:('-> ('Option.t, 'e) T2(M).t) ->
                              ('b t, 'e) T2(M).t
                          end
                        module Eager :
                          functor (T : Collection.Eager->
                            sig
                              val all :
                                ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                              val all_ignore :
                                ('a, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val sequence :
                                (Monoid.Unit.t, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val map :
                                'T.t ->
                                f:('-> ('b, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val iter :
                                'T.t ->
                                f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                init:'-> ('b, 'e) T2(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> ('a, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val exists :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val for_all :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val count :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (Monoid.Int.t, 'e) T2(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> ('a, 'e) T2(M).t) ->
                                ('a, 'e) T2(M).t
                              val find :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val find_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val filter :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                            end
                        module Delay :
                          functor (T : Collection.Delay->
                            sig
                              val all :
                                ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                              val all_ignore :
                                ('a, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val sequence :
                                (Monoid.Unit.t, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val map :
                                'T.t ->
                                f:('-> ('b, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val iter :
                                'T.t ->
                                f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                init:'-> ('b, 'e) T2(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> ('a, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val exists :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val for_all :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val count :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (Monoid.Int.t, 'e) T2(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> ('a, 'e) T2(M).t) ->
                                ('a, 'e) T2(M).t
                              val find :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val find_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val filter :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                            end
                      end
                    module List :
                      sig
                        val all :
                          ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t list ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t list ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'a list ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                        val iter :
                          'a list ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'a list ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'a list ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'a list ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'a list ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b list ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'a list ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('a list, 'e) T2(M).t
                        val filter_map :
                          'a list ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('b list, 'e) T2(M).t
                      end
                    module Seq :
                      sig
                        val all :
                          ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t
                          Core_kernel.Std.Sequence.t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('b, 'e) T2(M).t) ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                        val iter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'Core_kernel.Std.Sequence.t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'Core_kernel.Std.Sequence.t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                        val filter_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                      end
                    val ( >=> ) :
                      ('-> ('b, 'e) T2(M).t) ->
                      ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                    val ( !! ) : '-> ('a, 'e) T2(M).t
                    val ( !$ ) :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) T2(M).t
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                        module Let_syntax :
                          sig
                            val return : '-> ('a, 'b) T2(M).t
                            val bind :
                              ('a, 'e) T2(M).t ->
                              f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                            val map :
                              ('a, 'e) T2(M).t ->
                              f:('-> 'b) -> ('b, 'e) T2(M).t
                            val both :
                              ('a, 'e) T2(M).t ->
                              ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                      end
                    val bind :
                      ('a, 'e) T2(M).t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val return : '-> ('a, 'b) T2(M).t
                    val map :
                      ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                    val join :
                      (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val ignore_m :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                    val all_ignore :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    module Syntax :
                      sig
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                        val ( >=> ) :
                          ('-> ('b, 'e) T2(M).t) ->
                          ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                        val ( !! ) : '-> ('a, 'e) T2(M).t
                        val ( !$ ) :
                          ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t ->
                          ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t ->
                          ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                      end
                  end
            end
          module Cont :
            sig
              module type S =
                sig
                  type 'a t
                  type 'a m
                  type 'a e
                  val lift : 'a m -> 'a t
                  val run : 'a t -> 'a e
                  val void : 'a t -> Monoid.Unit.t t
                  val sequence : Monoid.Unit.t t List.t -> Monoid.Unit.t t
                  val forever : 'a t -> 'b t
                  module Fn :
                    sig
                      val id : '-> 'a t
                      val ignore : 'a t -> Monoid.Unit.t t
                      val nothing : Monoid.Unit.t -> Monoid.Unit.t t
                      val non : ('-> bool t) -> '-> bool t
                      val apply_n_times :
                        n:Monoid.Int.t -> ('-> 'a t) -> '-> 'a t
                      val compose :
                        ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
                    end
                  module Pair :
                    sig
                      val fst : ('a * 'b) t -> 'a t
                      val snd : ('a * 'b) t -> 'b t
                    end
                  module Triple :
                    sig
                      val fst : ('a * 'b * 'c) t -> 'a t
                      val snd : ('a * 'b * 'c) t -> 'b t
                      val trd : ('a * 'b * 'c) t -> 'c t
                    end
                  module Lift :
                    sig
                      val nullary : '-> 'a t
                      val unary : ('-> 'b) -> 'a t -> 'b t
                      val binary : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ternary :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val quaternary :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val quinary :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                  module Exn :
                    sig
                      val expect :
                        ?finally:(Monoid.Unit.t -> Monoid.Unit.t t) ->
                        f:(Monoid.Unit.t -> 'a t) ->
                        catch:(exn -> 'a t) -> 'a t
                    end
                  module Collection :
                    sig
                      module type S =
                        sig
                          type 'a t
                          val all : 'a t t -> 'a t t
                          val all_ignore : 'a t t -> Monoid.Unit.t t
                          val sequence : Monoid.Unit.t t t -> Monoid.Unit.t t
                          val map : 'a t -> f:('-> 'b t) -> 'b t t
                          val iter :
                            'a t ->
                            f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                          val fold :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_left :
                            'a t -> init:'-> f:('-> '-> 'b t) -> 'b t
                          val fold_right :
                            'a t -> f:('-> '-> 'b t) -> init:'-> 'b t
                          val reduce :
                            'a t -> f:('-> '-> 'a t) -> 'Option.t t
                          val exists : 'a t -> f:('-> bool t) -> bool t
                          val for_all : 'a t -> f:('-> bool t) -> bool t
                          val count :
                            'a t -> f:('-> bool t) -> Monoid.Int.t t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b t -> f:('-> 'a t) -> 'a t
                          val find :
                            'a t -> f:('-> bool t) -> 'Option.t t
                          val find_map :
                            'a t -> f:('-> 'Option.t t) -> 'Option.t t
                          val filter : 'a t -> f:('-> bool t) -> 'a t t
                          val filter_map :
                            'a t -> f:('-> 'Option.t t) -> 'b t t
                        end
                      module Eager :
                        functor (T : Collection.Eager->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'Option.t t
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t t) -> 'Option.t t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'Option.t t) -> 'T.t t
                          end
                      module Delay :
                        functor (T : Collection.Delay->
                          sig
                            val all : 'a t T.t -> 'T.t t
                            val all_ignore : 'a t T.t -> Monoid.Unit.t t
                            val sequence :
                              Monoid.Unit.t t T.t -> Monoid.Unit.t t
                            val map : 'T.t -> f:('-> 'b t) -> 'T.t t
                            val iter :
                              'T.t ->
                              f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                            val fold :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_left :
                              'T.t ->
                              init:'-> f:('-> '-> 'b t) -> 'b t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> 'b t) -> init:'-> 'b t
                            val reduce :
                              'T.t -> f:('-> '-> 'a t) -> 'Option.t t
                            val exists : 'T.t -> f:('-> bool t) -> bool t
                            val for_all :
                              'T.t -> f:('-> bool t) -> bool t
                            val count :
                              'T.t -> f:('-> bool t) -> Monoid.Int.t t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> 'a t) -> 'a t
                            val find :
                              'T.t -> f:('-> bool t) -> 'Option.t t
                            val find_map :
                              'T.t ->
                              f:('-> 'Option.t t) -> 'Option.t t
                            val filter :
                              'T.t -> f:('-> bool t) -> 'T.t t
                            val filter_map :
                              'T.t -> f:('-> 'Option.t t) -> 'T.t t
                          end
                    end
                  module List :
                    sig
                      val all : 'a t List.t -> 'List.t t
                      val all_ignore : 'a t List.t -> Monoid.Unit.t t
                      val sequence :
                        Monoid.Unit.t t List.t -> Monoid.Unit.t t
                      val map : 'List.t -> f:('-> 'b t) -> 'List.t t
                      val iter :
                        'List.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'List.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'List.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'List.t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'List.t -> f:('-> bool t) -> bool t
                      val for_all : 'List.t -> f:('-> bool t) -> bool t
                      val count :
                        'List.t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'List.t -> f:('-> 'a t) -> 'a t
                      val find :
                        'List.t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'List.t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter :
                        'List.t -> f:('-> bool t) -> 'List.t t
                      val filter_map :
                        'List.t -> f:('-> 'Option.t t) -> 'List.t t
                    end
                  module Seq :
                    sig
                      val all : 'a t Seq.t -> 'Seq.t t
                      val all_ignore : 'a t Seq.t -> Monoid.Unit.t t
                      val sequence : Monoid.Unit.t t Seq.t -> Monoid.Unit.t t
                      val map : 'Seq.t -> f:('-> 'b t) -> 'Seq.t t
                      val iter :
                        'Seq.t ->
                        f:('-> Monoid.Unit.t t) -> Monoid.Unit.t t
                      val fold :
                        'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_left :
                        'Seq.t -> init:'-> f:('-> '-> 'b t) -> 'b t
                      val fold_right :
                        'Seq.t -> f:('-> '-> 'b t) -> init:'-> 'b t
                      val reduce :
                        'Seq.t -> f:('-> '-> 'a t) -> 'Option.t t
                      val exists : 'Seq.t -> f:('-> bool t) -> bool t
                      val for_all : 'Seq.t -> f:('-> bool t) -> bool t
                      val count :
                        'Seq.t -> f:('-> bool t) -> Monoid.Int.t t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'Seq.t -> f:('-> 'a t) -> 'a t
                      val find :
                        'Seq.t -> f:('-> bool t) -> 'Option.t t
                      val find_map :
                        'Seq.t -> f:('-> 'Option.t t) -> 'Option.t t
                      val filter : 'Seq.t -> f:('-> bool t) -> 'Seq.t t
                      val filter_map :
                        'Seq.t -> f:('-> 'Option.t t) -> 'Seq.t t
                    end
                  val ( >=> ) : ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                  val ( !! ) : '-> 'a t
                  val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                  val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) -> 'a t -> 'b t -> 'c t -> 'd t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                  module Monad_infix :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                    end
                  val bind : 'a t -> f:('-> 'b t) -> 'b t
                  val return : '-> 'a t
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val join : 'a t t -> 'a t
                  val ignore_m : 'a t -> Monoid.Unit.t t
                  val all : 'a t list -> 'a list t
                  val all_ignore : Monoid.Unit.t t list -> Monoid.Unit.t t
                  module Let_syntax :
                    sig
                      val return : '-> 'a t
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      module Let_syntax :
                        sig
                          val return : '-> 'a t
                          val bind : 'a t -> f:('-> 'b t) -> 'b t
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val both : 'a t -> 'b t -> ('a * 'b) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Syntax :
                    sig
                      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                      val ( >=> ) :
                        ('-> 'b t) -> ('-> 'c t) -> '-> 'c t
                      val ( !! ) : '-> 'a t
                      val ( !$ ) : ('-> 'b) -> 'a t -> 'b t
                      val ( !$$ ) : ('-> '-> 'c) -> 'a t -> 'b t -> 'c t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        'a t -> 'b t -> 'c t -> 'd t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t
                    end
                  type r
                  val call : f:(cc:('-> 'b t) -> 'a t) -> 'a t
                end
              module type S2 =
                sig
                  type ('a, 'e) t
                  type 'a m
                  type ('a, 'e) e
                  val lift : 'a m -> ('a, 'e) t
                  val run : ('a, 'e) t -> ('a, 'e) e
                  val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val forever : ('a, 'e) t -> ('b, 'e) t
                  module Fn :
                    sig
                      val id : '-> ('a, 'e) t
                      val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                      val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                      val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                      val apply_n_times :
                        n:Monoid.Int.t ->
                        ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                      val compose :
                        ('-> ('c, 'e) t) ->
                        ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                    end
                  module Pair :
                    sig
                      val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                      val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                    end
                  module Triple :
                    sig
                      val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                      val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                      val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                    end
                  module Lift :
                    sig
                      val nullary : '-> ('a, 'e) t
                      val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                      val binary :
                        ('-> '-> 'c) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                      val ternary :
                        ('-> '-> '-> 'd) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                      val quaternary :
                        ('-> '-> '-> '-> 'e) ->
                        ('a, 's) t ->
                        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                      val quinary :
                        ('-> '-> '-> '-> '-> 'f) ->
                        ('a, 's) t ->
                        ('b, 's) t ->
                        ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                    end
                  module Exn :
                    sig
                      val expect :
                        ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                        f:(Monoid.Unit.t -> ('a, 's) t) ->
                        catch:(exn -> ('a, 's) t) -> ('a, 's) t
                    end
                  module Collection :
                    sig
                      module type S =
                        sig
                          type 'a t
                          val all : ('a, 'e) t t -> ('a t, 'e) t
                          val all_ignore :
                            ('a, 'e) t t -> (Monoid.Unit.t, 'e) t
                          val sequence :
                            (Monoid.Unit.t, 'e) t t -> (Monoid.Unit.t, 'e) t
                          val map :
                            'a t -> f:('-> ('b, 'e) t) -> ('b t, 'e) t
                          val iter :
                            'a t ->
                            f:('-> (Monoid.Unit.t, 'e) t) ->
                            (Monoid.Unit.t, 'e) t
                          val fold :
                            'a t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_left :
                            'a t ->
                            init:'->
                            f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                          val fold_right :
                            'a t ->
                            f:('-> '-> ('b, 'e) t) ->
                            init:'-> ('b, 'e) t
                          val reduce :
                            'a t ->
                            f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                          val exists :
                            'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val for_all :
                            'a t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                          val count :
                            'a t ->
                            f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                          val map_reduce :
                            (module Monoid.S with type t = 'a) ->
                            'b t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                          val find :
                            'a t ->
                            f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                          val find_map :
                            'a t ->
                            f:('-> ('Option.t, 'e) t) ->
                            ('Option.t, 'e) t
                          val filter :
                            'a t -> f:('-> (bool, 'e) t) -> ('a t, 'e) t
                          val filter_map :
                            'a t ->
                            f:('-> ('Option.t, 'e) t) -> ('b t, 'e) t
                        end
                      module Eager :
                        functor (T : Collection.Eager->
                          sig
                            val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                            val all_ignore :
                              ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                            val sequence :
                              (Monoid.Unit.t, 'e) t T.t ->
                              (Monoid.Unit.t, 'e) t
                            val map :
                              'T.t ->
                              f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                            val iter :
                              'T.t ->
                              f:('-> (Monoid.Unit.t, 'e) t) ->
                              (Monoid.Unit.t, 'e) t
                            val fold :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_left :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> ('b, 'e) t) ->
                              init:'-> ('b, 'e) t
                            val reduce :
                              'T.t ->
                              f:('-> '-> ('a, 'e) t) ->
                              ('Option.t, 'e) t
                            val exists :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val for_all :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val count :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                            val find :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                            val find_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) ->
                              ('Option.t, 'e) t
                            val filter :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                            val filter_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                          end
                      module Delay :
                        functor (T : Collection.Delay->
                          sig
                            val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                            val all_ignore :
                              ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                            val sequence :
                              (Monoid.Unit.t, 'e) t T.t ->
                              (Monoid.Unit.t, 'e) t
                            val map :
                              'T.t ->
                              f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                            val iter :
                              'T.t ->
                              f:('-> (Monoid.Unit.t, 'e) t) ->
                              (Monoid.Unit.t, 'e) t
                            val fold :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_left :
                              'T.t ->
                              init:'->
                              f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                            val fold_right :
                              'T.t ->
                              f:('-> '-> ('b, 'e) t) ->
                              init:'-> ('b, 'e) t
                            val reduce :
                              'T.t ->
                              f:('-> '-> ('a, 'e) t) ->
                              ('Option.t, 'e) t
                            val exists :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val for_all :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (bool, 'e) t
                            val count :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                            val find :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                            val find_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) ->
                              ('Option.t, 'e) t
                            val filter :
                              'T.t ->
                              f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                            val filter_map :
                              'T.t ->
                              f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                          end
                    end
                  module List :
                    sig
                      val all : ('a, 'e) t List.t -> ('List.t, 'e) t
                      val all_ignore :
                        ('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                      val map :
                        'List.t ->
                        f:('-> ('b, 'e) t) -> ('List.t, 'e) t
                      val iter :
                        'List.t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'List.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'List.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'List.t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'List.t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'List.t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'List.t ->
                        f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'List.t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'List.t ->
                        f:('-> (bool, 'e) t) -> ('List.t, 'e) t
                      val filter_map :
                        'List.t ->
                        f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
                    end
                  module Seq :
                    sig
                      val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
                      val all_ignore :
                        ('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                      val sequence :
                        (Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                      val map :
                        'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
                      val iter :
                        'Seq.t ->
                        f:('-> (Monoid.Unit.t, 'e) t) ->
                        (Monoid.Unit.t, 'e) t
                      val fold :
                        'Seq.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_left :
                        'Seq.t ->
                        init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                      val fold_right :
                        'Seq.t ->
                        f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                      val reduce :
                        'Seq.t ->
                        f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                      val exists :
                        'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val for_all :
                        'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                      val count :
                        'Seq.t ->
                        f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                      val find :
                        'Seq.t ->
                        f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                      val find_map :
                        'Seq.t ->
                        f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                      val filter :
                        'Seq.t ->
                        f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
                      val filter_map :
                        'Seq.t ->
                        f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
                    end
                  val ( >=> ) :
                    ('-> ('b, 'e) t) ->
                    ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                  val ( !! ) : '-> ('a, 'e) t
                  val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      module Let_syntax :
                        sig
                          val return : '-> ('a, 'b) t
                          val bind :
                            ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                          val both :
                            ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Monad_infix :
                    sig
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                    end
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val return : '-> ('a, 'b) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                  val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val all : ('a, 'e) t list -> ('a list, 'e) t
                  val all_ignore :
                    (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
                  module Syntax :
                    sig
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      val ( >=> ) :
                        ('-> ('b, 'e) t) ->
                        ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                      val ( !! ) : '-> ('a, 'e) t
                      val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                      val ( !$$ ) :
                        ('-> '-> 'c) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                      val ( !$$$ ) :
                        ('-> '-> '-> 'd) ->
                        ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                      val ( !$$$$ ) :
                        ('-> '-> '-> '-> 'e) ->
                        ('a, 's) t ->
                        ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                      val ( !$$$$$ ) :
                        ('-> '-> '-> '-> '-> 'f) ->
                        ('a, 's) t ->
                        ('b, 's) t ->
                        ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                    end
                  val call :
                    f:(cc:('-> ('b, 'e) t) -> ('a, 'e) t) -> ('a, 'e) t
                end
              type ('a, 'r) cont
              type ('a, 'r) t = ('a, 'r) cont
              type 'a m = 'a
              type ('a, 'e) e = ('-> 'e) -> 'e
              val lift : '-> ('a, 'e) t
              val run : ('a, 'e) t -> ('a, 'e) e
              val void : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val sequence :
                (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
              val forever : ('a, 'e) t -> ('b, 'e) t
              module Fn :
                sig
                  val id : '-> ('a, 'e) t
                  val ignore : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
                  val nothing : Monoid.Unit.t -> (Monoid.Unit.t, 'e) t
                  val non : ('-> (bool, 'e) t) -> '-> (bool, 'e) t
                  val apply_n_times :
                    n:Monoid.Int.t -> ('-> ('a, 'e) t) -> '-> ('a, 'e) t
                  val compose :
                    ('-> ('c, 'e) t) ->
                    ('-> ('b, 'e) t) -> '-> ('c, 'e) t
                end
              module Pair :
                sig
                  val fst : ('a * 'b, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b, 'e) t -> ('b, 'e) t
                end
              module Triple :
                sig
                  val fst : ('a * 'b * 'c, 'e) t -> ('a, 'e) t
                  val snd : ('a * 'b * 'c, 'e) t -> ('b, 'e) t
                  val trd : ('a * 'b * 'c, 'e) t -> ('c, 'e) t
                end
              module Lift :
                sig
                  val nullary : '-> ('a, 'e) t
                  val unary : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val binary :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ternary :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val quaternary :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val quinary :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
              module Exn :
                sig
                  val expect :
                    ?finally:(Monoid.Unit.t -> (Monoid.Unit.t, 's) t) ->
                    f:(Monoid.Unit.t -> ('a, 's) t) ->
                    catch:(exn -> ('a, 's) t) -> ('a, 's) t
                end
              module Collection :
                sig
                  module type S =
                    sig
                      type 'a t
                      val all : ('a, 'e) cont t -> ('a t, 'e) cont
                      val all_ignore :
                        ('a, 'e) cont t -> (Monoid.Unit.t, 'e) cont
                      val sequence :
                        (Monoid.Unit.t, 'e) cont t ->
                        (Monoid.Unit.t, 'e) cont
                      val map :
                        'a t -> f:('-> ('b, 'e) cont) -> ('b t, 'e) cont
                      val iter :
                        'a t ->
                        f:('-> (Monoid.Unit.t, 'e) cont) ->
                        (Monoid.Unit.t, 'e) cont
                      val fold :
                        'a t ->
                        init:'->
                        f:('-> '-> ('b, 'e) cont) -> ('b, 'e) cont
                      val fold_left :
                        'a t ->
                        init:'->
                        f:('-> '-> ('b, 'e) cont) -> ('b, 'e) cont
                      val fold_right :
                        'a t ->
                        f:('-> '-> ('b, 'e) cont) ->
                        init:'-> ('b, 'e) cont
                      val reduce :
                        'a t ->
                        f:('-> '-> ('a, 'e) cont) ->
                        ('Option.t, 'e) cont
                      val exists :
                        'a t -> f:('-> (bool, 'e) cont) -> (bool, 'e) cont
                      val for_all :
                        'a t -> f:('-> (bool, 'e) cont) -> (bool, 'e) cont
                      val count :
                        'a t ->
                        f:('-> (bool, 'e) cont) -> (Monoid.Int.t, 'e) cont
                      val map_reduce :
                        (module Monoid.S with type t = 'a) ->
                        'b t -> f:('-> ('a, 'e) cont) -> ('a, 'e) cont
                      val find :
                        'a t ->
                        f:('-> (bool, 'e) cont) -> ('Option.t, 'e) cont
                      val find_map :
                        'a t ->
                        f:('-> ('Option.t, 'e) cont) ->
                        ('Option.t, 'e) cont
                      val filter :
                        'a t -> f:('-> (bool, 'e) cont) -> ('a t, 'e) cont
                      val filter_map :
                        'a t ->
                        f:('-> ('Option.t, 'e) cont) -> ('b t, 'e) cont
                    end
                  module Eager :
                    functor (T : Collection.Eager->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) ->
                          ('Option.t, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                      end
                  module Delay :
                    functor (T : Collection.Delay->
                      sig
                        val all : ('a, 'e) t T.t -> ('T.t, 'e) t
                        val all_ignore :
                          ('a, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val sequence :
                          (Monoid.Unit.t, 'e) t T.t -> (Monoid.Unit.t, 'e) t
                        val map :
                          'T.t -> f:('-> ('b, 'e) t) -> ('T.t, 'e) t
                        val iter :
                          'T.t ->
                          f:('-> (Monoid.Unit.t, 'e) t) ->
                          (Monoid.Unit.t, 'e) t
                        val fold :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_left :
                          'T.t ->
                          init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                        val fold_right :
                          'T.t ->
                          f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                        val reduce :
                          'T.t ->
                          f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                        val exists :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val for_all :
                          'T.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                        val count :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'T.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                        val find :
                          'T.t ->
                          f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                        val find_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) ->
                          ('Option.t, 'e) t
                        val filter :
                          'T.t -> f:('-> (bool, 'e) t) -> ('T.t, 'e) t
                        val filter_map :
                          'T.t ->
                          f:('-> ('Option.t, 'e) t) -> ('T.t, 'e) t
                      end
                end
              module List :
                sig
                  val all : ('a, 'e) t List.t -> ('List.t, 'e) t
                  val all_ignore : ('a, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t List.t -> (Monoid.Unit.t, 'e) t
                  val map :
                    'List.t -> f:('-> ('b, 'e) t) -> ('List.t, 'e) t
                  val iter :
                    'List.t ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'List.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'List.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'List.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'List.t ->
                    f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists :
                    'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'List.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'List.t ->
                    f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'List.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'List.t ->
                    f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'List.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter :
                    'List.t -> f:('-> (bool, 'e) t) -> ('List.t, 'e) t
                  val filter_map :
                    'List.t ->
                    f:('-> ('Option.t, 'e) t) -> ('List.t, 'e) t
                end
              module Seq :
                sig
                  val all : ('a, 'e) t Seq.t -> ('Seq.t, 'e) t
                  val all_ignore : ('a, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                  val sequence :
                    (Monoid.Unit.t, 'e) t Seq.t -> (Monoid.Unit.t, 'e) t
                  val map :
                    'Seq.t -> f:('-> ('b, 'e) t) -> ('Seq.t, 'e) t
                  val iter :
                    'Seq.t ->
                    f:('-> (Monoid.Unit.t, 'e) t) -> (Monoid.Unit.t, 'e) t
                  val fold :
                    'Seq.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_left :
                    'Seq.t ->
                    init:'-> f:('-> '-> ('b, 'e) t) -> ('b, 'e) t
                  val fold_right :
                    'Seq.t ->
                    f:('-> '-> ('b, 'e) t) -> init:'-> ('b, 'e) t
                  val reduce :
                    'Seq.t ->
                    f:('-> '-> ('a, 'e) t) -> ('Option.t, 'e) t
                  val exists :
                    'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val for_all :
                    'Seq.t -> f:('-> (bool, 'e) t) -> (bool, 'e) t
                  val count :
                    'Seq.t ->
                    f:('-> (bool, 'e) t) -> (Monoid.Int.t, 'e) t
                  val map_reduce :
                    (module Monoid.S with type t = 'a) ->
                    'Seq.t -> f:('-> ('a, 'e) t) -> ('a, 'e) t
                  val find :
                    'Seq.t -> f:('-> (bool, 'e) t) -> ('Option.t, 'e) t
                  val find_map :
                    'Seq.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Option.t, 'e) t
                  val filter :
                    'Seq.t -> f:('-> (bool, 'e) t) -> ('Seq.t, 'e) t
                  val filter_map :
                    'Seq.t ->
                    f:('-> ('Option.t, 'e) t) -> ('Seq.t, 'e) t
                end
              val ( >=> ) :
                ('-> ('b, 'e) t) -> ('-> ('c, 'e) t) -> '-> ('c, 'e) t
              val ( !! ) : '-> ('a, 'e) t
              val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
              val ( !$$ ) :
                ('-> '-> 'c) -> ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
              val ( !$$$ ) :
                ('-> '-> '-> 'd) ->
                ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
              val ( !$$$$ ) :
                ('-> '-> '-> '-> 'e) ->
                ('a, 's) t ->
                ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
              val ( !$$$$$ ) :
                ('-> '-> '-> '-> '-> 'f) ->
                ('a, 's) t ->
                ('b, 's) t ->
                ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val bind :
                        ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                      val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Monad_infix :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                end
              val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
              val return : '-> ('a, 'b) t
              val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
              val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
              val ignore_m : ('a, 'e) t -> (Monoid.Unit.t, 'e) t
              val all : ('a, 'e) t list -> ('a list, 'e) t
              val all_ignore :
                (Monoid.Unit.t, 'e) t list -> (Monoid.Unit.t, 'e) t
              module Syntax :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  val ( >=> ) :
                    ('-> ('b, 'e) t) ->
                    ('-> ('c, 'e) t) -> '-> ('c, 'e) t
                  val ( !! ) : '-> ('a, 'e) t
                  val ( !$ ) : ('-> 'b) -> ('a, 'e) t -> ('b, 'e) t
                  val ( !$$ ) :
                    ('-> '-> 'c) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t
                  val ( !$$$ ) :
                    ('-> '-> '-> 'd) ->
                    ('a, 'e) t -> ('b, 'e) t -> ('c, 'e) t -> ('d, 'e) t
                  val ( !$$$$ ) :
                    ('-> '-> '-> '-> 'e) ->
                    ('a, 's) t ->
                    ('b, 's) t -> ('c, 's) t -> ('d, 's) t -> ('e, 's) t
                  val ( !$$$$$ ) :
                    ('-> '-> '-> '-> '-> 'f) ->
                    ('a, 's) t ->
                    ('b, 's) t ->
                    ('c, 's) t -> ('d, 's) t -> ('e, 's) t -> ('f, 's) t
                end
              val call :
                f:(cc:('-> ('b, 'e) t) -> ('a, 'e) t) -> ('a, 'e) t
              module T1 :
                functor (T : Core_kernel.Std.T) (M : Monad->
                  sig
                    type r = T.t
                    type 'a m = 'M.t
                    type 'a t =
                        ('a,
                         Monads.Std.Monad.Cont.T1.r
                         Monads.Std.Monad.Cont.T1.m)
                        Monads.Std.Monad.Cont.cont
                    type 'a e =
                        ('->
                         Monads.Std.Monad.Cont.T1.r
                         Monads.Std.Monad.Cont.T1.m) ->
                        Monads.Std.Monad.Cont.T1.r Monads.Std.Monad.Cont.T1.m
                  end
              module T2 :
                functor (M : Monad->
                  sig
                    type 'a m = 'M.t
                    type ('a, 'e) t =
                        ('a, 'Monads.Std.Monad.Cont.T2.m)
                        Monads.Std.Monad.Cont.cont
                    type ('a, 'e) e =
                        ('-> 'Monads.Std.Monad.Cont.T2.m) ->
                        'Monads.Std.Monad.Cont.T2.m
                  end
              module Make :
                functor (T : Core_kernel.Std.T) (M : Monad->
                  sig
                    val lift : 'M.t -> 'T1(T)(M).t
                    val run : 'T1(T)(M).t -> 'T1(T)(M).e
                    val void : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                    val sequence :
                      Monoid.Unit.t T1(T)(M).t list ->
                      Monoid.Unit.t T1(T)(M).t
                    val forever : 'T1(T)(M).t -> 'T1(T)(M).t
                    module Fn :
                      sig
                        val id : '-> 'T1(T)(M).t
                        val ignore :
                          'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                        val nothing :
                          Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t
                        val non :
                          ('-> bool T1(T)(M).t) -> '-> bool T1(T)(M).t
                        val apply_n_times :
                          n:Monoid.Int.t ->
                          ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                        val compose :
                          ('-> 'T1(T)(M).t) ->
                          ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                      end
                    module Pair :
                      sig
                        val fst : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                        val snd : ('a * 'b) T1(T)(M).t -> 'T1(T)(M).t
                      end
                    module Triple :
                      sig
                        val fst : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                        val snd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                        val trd : ('a * 'b * 'c) T1(T)(M).t -> 'T1(T)(M).t
                      end
                    module Lift :
                      sig
                        val nullary : '-> 'T1(T)(M).t
                        val unary :
                          ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val binary :
                          ('-> '-> 'c) ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ternary :
                          ('-> '-> '-> 'd) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val quaternary :
                          ('-> '-> '-> '-> 'e) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val quinary :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                      end
                    module Exn :
                      sig
                        val expect :
                          ?finally:(Monoid.Unit.t -> Monoid.Unit.t T1(T)(M).t) ->
                          f:(Monoid.Unit.t -> 'T1(T)(M).t) ->
                          catch:(exn -> 'T1(T)(M).t) -> 'T1(T)(M).t
                      end
                    module Collection :
                      sig
                        module type S =
                          sig
                            type 'a t
                            val all : 'T1(T)(M).t t -> 'a t T1(T)(M).t
                            val all_ignore :
                              'T1(T)(M).t t -> Monoid.Unit.t T1(T)(M).t
                            val sequence :
                              Monoid.Unit.t T1(T)(M).t t ->
                              Monoid.Unit.t T1(T)(M).t
                            val map :
                              'a t ->
                              f:('-> 'T1(T)(M).t) -> 'b t T1(T)(M).t
                            val iter :
                              'a t ->
                              f:('-> Monoid.Unit.t T1(T)(M).t) ->
                              Monoid.Unit.t T1(T)(M).t
                            val fold :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val fold_left :
                              'a t ->
                              init:'->
                              f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val fold_right :
                              'a t ->
                              f:('-> '-> 'T1(T)(M).t) ->
                              init:'-> 'T1(T)(M).t
                            val reduce :
                              'a t ->
                              f:('-> '-> 'T1(T)(M).t) ->
                              'Option.t T1(T)(M).t
                            val exists :
                              'a t ->
                              f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                            val for_all :
                              'a t ->
                              f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                            val count :
                              'a t ->
                              f:('-> bool T1(T)(M).t) ->
                              Monoid.Int.t T1(T)(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b t ->
                              f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val find :
                              'a t ->
                              f:('-> bool T1(T)(M).t) ->
                              'Option.t T1(T)(M).t
                            val find_map :
                              'a t ->
                              f:('-> 'Option.t T1(T)(M).t) ->
                              'Option.t T1(T)(M).t
                            val filter :
                              'a t ->
                              f:('-> bool T1(T)(M).t) -> 'a t T1(T)(M).t
                            val filter_map :
                              'a t ->
                              f:('-> 'Option.t T1(T)(M).t) ->
                              'b t T1(T)(M).t
                          end
                        module Eager :
                          functor (T : Collection.Eager->
                            sig
                              val all :
                                'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                              val all_ignore :
                                'T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
                              val sequence :
                                Monoid.Unit.t T1(T)(M).t T.t ->
                                Monoid.Unit.t T1(T)(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T1(T)(M).t) ->
                                Monoid.Unit.t T1(T)(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'T1(T)(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'T1(T)(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T1(T)(M).t) ->
                                init:'-> 'T1(T)(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                Monoid.Int.t T1(T)(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'Option.t T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                'T.t T1(T)(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'Option.t T1(T)(M).t) ->
                                'T.t T1(T)(M).t
                            end
                        module Delay :
                          functor (T : Collection.Delay->
                            sig
                              val all :
                                'T1(T)(M).t T.t -> 'T.t T1(T)(M).t
                              val all_ignore :
                                'T1(T)(M).t T.t -> Monoid.Unit.t T1(T)(M).t
                              val sequence :
                                Monoid.Unit.t T1(T)(M).t T.t ->
                                Monoid.Unit.t T1(T)(M).t
                              val map :
                                'T.t ->
                                f:('-> 'T1(T)(M).t) -> 'T.t T1(T)(M).t
                              val iter :
                                'T.t ->
                                f:('-> Monoid.Unit.t T1(T)(M).t) ->
                                Monoid.Unit.t T1(T)(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'T1(T)(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'T1(T)(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> 'T1(T)(M).t) ->
                                init:'-> 'T1(T)(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> 'T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val exists :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                              val for_all :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                              val count :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                Monoid.Int.t T1(T)(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                              val find :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val find_map :
                                'T.t ->
                                f:('-> 'Option.t T1(T)(M).t) ->
                                'Option.t T1(T)(M).t
                              val filter :
                                'T.t ->
                                f:('-> bool T1(T)(M).t) ->
                                'T.t T1(T)(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> 'Option.t T1(T)(M).t) ->
                                'T.t T1(T)(M).t
                            end
                      end
                    module List :
                      sig
                        val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                        val all_ignore :
                          'T1(T)(M).t list -> Monoid.Unit.t T1(T)(M).t
                        val sequence :
                          Monoid.Unit.t T1(T)(M).t list ->
                          Monoid.Unit.t T1(T)(M).t
                        val map :
                          'a list ->
                          f:('-> 'T1(T)(M).t) -> 'b list T1(T)(M).t
                        val iter :
                          'a list ->
                          f:('-> Monoid.Unit.t T1(T)(M).t) ->
                          Monoid.Unit.t T1(T)(M).t
                        val fold :
                          'a list ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_left :
                          'a list ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_right :
                          'a list ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          init:'-> 'T1(T)(M).t
                        val reduce :
                          'a list ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val exists :
                          'a list ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val for_all :
                          'a list ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val count :
                          'a list ->
                          f:('-> bool T1(T)(M).t) ->
                          Monoid.Int.t T1(T)(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b list -> f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val find :
                          'a list ->
                          f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                        val find_map :
                          'a list ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val filter :
                          'a list ->
                          f:('-> bool T1(T)(M).t) -> 'a list T1(T)(M).t
                        val filter_map :
                          'a list ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'b list T1(T)(M).t
                      end
                    module Seq :
                      sig
                        val all :
                          'T1(T)(M).t Core_kernel.Std.Sequence.t ->
                          'Core_kernel.Std.Sequence.t T1(T)(M).t
                        val all_ignore :
                          'T1(T)(M).t Core_kernel.Std.Sequence.t ->
                          Monoid.Unit.t T1(T)(M).t
                        val sequence :
                          Monoid.Unit.t T1(T)(M).t Core_kernel.Std.Sequence.t ->
                          Monoid.Unit.t T1(T)(M).t
                        val map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'T1(T)(M).t) ->
                          'Core_kernel.Std.Sequence.t T1(T)(M).t
                        val iter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> Monoid.Unit.t T1(T)(M).t) ->
                          Monoid.Unit.t T1(T)(M).t
                        val fold :
                          'Core_kernel.Std.Sequence.t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_left :
                          'Core_kernel.Std.Sequence.t ->
                          init:'->
                          f:('-> '-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val fold_right :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          init:'-> 'T1(T)(M).t
                        val reduce :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> 'T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val exists :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val for_all :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(T)(M).t) -> bool T1(T)(M).t
                        val count :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(T)(M).t) ->
                          Monoid.Int.t T1(T)(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val find :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(T)(M).t) -> 'Option.t T1(T)(M).t
                        val find_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'Option.t T1(T)(M).t
                        val filter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> bool T1(T)(M).t) ->
                          'Core_kernel.Std.Sequence.t T1(T)(M).t
                        val filter_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> 'Option.t T1(T)(M).t) ->
                          'Core_kernel.Std.Sequence.t T1(T)(M).t
                      end
                    val ( >=> ) :
                      ('-> 'T1(T)(M).t) ->
                      ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                    val ( !! ) : '-> 'T1(T)(M).t
                    val ( !$ ) : ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t ->
                      'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                    val ( >>= ) :
                      'T1(T)(M).t -> ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val ( >>| ) :
                      'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          'T1(T)(M).t ->
                          ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val ( >>| ) :
                          'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                      end
                    val bind :
                      'T1(T)(M).t ->
                      f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                    val return : '-> 'T1(T)(M).t
                    val map : 'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                    val join : 'T1(T)(M).t T1(T)(M).t -> 'T1(T)(M).t
                    val ignore_m : 'T1(T)(M).t -> Monoid.Unit.t T1(T)(M).t
                    val all : 'T1(T)(M).t list -> 'a list T1(T)(M).t
                    val all_ignore :
                      Monoid.Unit.t T1(T)(M).t list ->
                      Monoid.Unit.t T1(T)(M).t
                    module Let_syntax :
                      sig
                        val return : '-> 'T1(T)(M).t
                        val ( >>= ) :
                          'T1(T)(M).t ->
                          ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val ( >>| ) :
                          'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                        module Let_syntax :
                          sig
                            val return : '-> 'T1(T)(M).t
                            val bind :
                              'T1(T)(M).t ->
                              f:('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                            val map :
                              'T1(T)(M).t -> f:('-> 'b) -> 'T1(T)(M).t
                            val both :
                              'T1(T)(M).t ->
                              'T1(T)(M).t -> ('a * 'b) T1(T)(M).t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Syntax :
                      sig
                        val ( >>= ) :
                          'T1(T)(M).t ->
                          ('-> 'T1(T)(M).t) -> 'T1(T)(M).t
                        val ( >>| ) :
                          'T1(T)(M).t -> ('-> 'b) -> 'T1(T)(M).t
                        val ( >=> ) :
                          ('-> 'T1(T)(M).t) ->
                          ('-> 'T1(T)(M).t) -> '-> 'T1(T)(M).t
                        val ( !! ) : '-> 'T1(T)(M).t
                        val ( !$ ) :
                          ('-> 'b) -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t ->
                          'T1(T)(M).t -> 'T1(T)(M).t -> 'T1(T)(M).t
                      end
                    val call :
                      f:(cc:('-> 'T1(T)(M).t) -> 'T1(T)(M).t) ->
                      'T1(T)(M).t
                  end
              module Make2 :
                functor (M : Monad->
                  sig
                    val lift : 'M.t -> ('a, 'e) T2(M).t
                    val run : ('a, 'e) T2(M).t -> ('a, 'e) T2(M).e
                    val void :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val sequence :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    val forever : ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    module Fn :
                      sig
                        val id : '-> ('a, 'e) T2(M).t
                        val ignore :
                          ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                        val nothing :
                          Monoid.Unit.t -> (Monoid.Unit.t, 'e) T2(M).t
                        val non :
                          ('-> (bool, 'e) T2(M).t) ->
                          '-> (bool, 'e) T2(M).t
                        val apply_n_times :
                          n:Monoid.Int.t ->
                          ('-> ('a, 'e) T2(M).t) -> '-> ('a, 'e) T2(M).t
                        val compose :
                          ('-> ('c, 'e) T2(M).t) ->
                          ('-> ('b, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                      end
                    module Pair :
                      sig
                        val fst : ('a * 'b, 'e) T2(M).t -> ('a, 'e) T2(M).t
                        val snd : ('a * 'b, 'e) T2(M).t -> ('b, 'e) T2(M).t
                      end
                    module Triple :
                      sig
                        val fst :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('a, 'e) T2(M).t
                        val snd :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val trd :
                          ('a * 'b * 'c, 'e) T2(M).t -> ('c, 'e) T2(M).t
                      end
                    module Lift :
                      sig
                        val nullary : '-> ('a, 'e) T2(M).t
                        val unary :
                          ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val binary :
                          ('-> '-> 'c) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                        val ternary :
                          ('-> '-> '-> 'd) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t ->
                          ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                        val quaternary :
                          ('-> '-> '-> '-> 'e) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                        val quinary :
                          ('-> '-> '-> '-> '-> 'f) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t ->
                          ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                      end
                    module Exn :
                      sig
                        val expect :
                          ?finally:(Monoid.Unit.t ->
                                    (Monoid.Unit.t, 's) T2(M).t) ->
                          f:(Monoid.Unit.t -> ('a, 's) T2(M).t) ->
                          catch:(exn -> ('a, 's) T2(M).t) -> ('a, 's) T2(M).t
                      end
                    module Collection :
                      sig
                        module type S =
                          sig
                            type 'a t
                            val all :
                              ('a, 'e) T2(M).t t -> ('a t, 'e) T2(M).t
                            val all_ignore :
                              ('a, 'e) T2(M).t t ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val sequence :
                              (Monoid.Unit.t, 'e) T2(M).t t ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val map :
                              'a t ->
                              f:('-> ('b, 'e) T2(M).t) ->
                              ('b t, 'e) T2(M).t
                            val iter :
                              'a t ->
                              f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                              (Monoid.Unit.t, 'e) T2(M).t
                            val fold :
                              'a t ->
                              init:'->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              ('b, 'e) T2(M).t
                            val fold_left :
                              'a t ->
                              init:'->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              ('b, 'e) T2(M).t
                            val fold_right :
                              'a t ->
                              f:('-> '-> ('b, 'e) T2(M).t) ->
                              init:'-> ('b, 'e) T2(M).t
                            val reduce :
                              'a t ->
                              f:('-> '-> ('a, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val exists :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (bool, 'e) T2(M).t
                            val for_all :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (bool, 'e) T2(M).t
                            val count :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              (Monoid.Int.t, 'e) T2(M).t
                            val map_reduce :
                              (module Monoid.S with type t = 'a) ->
                              'b t ->
                              f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                            val find :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val find_map :
                              'a t ->
                              f:('-> ('Option.t, 'e) T2(M).t) ->
                              ('Option.t, 'e) T2(M).t
                            val filter :
                              'a t ->
                              f:('-> (bool, 'e) T2(M).t) ->
                              ('a t, 'e) T2(M).t
                            val filter_map :
                              'a t ->
                              f:('-> ('Option.t, 'e) T2(M).t) ->
                              ('b t, 'e) T2(M).t
                          end
                        module Eager :
                          functor (T : Collection.Eager->
                            sig
                              val all :
                                ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                              val all_ignore :
                                ('a, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val sequence :
                                (Monoid.Unit.t, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val map :
                                'T.t ->
                                f:('-> ('b, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val iter :
                                'T.t ->
                                f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                init:'-> ('b, 'e) T2(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> ('a, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val exists :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val for_all :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val count :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (Monoid.Int.t, 'e) T2(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> ('a, 'e) T2(M).t) ->
                                ('a, 'e) T2(M).t
                              val find :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val find_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val filter :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                            end
                        module Delay :
                          functor (T : Collection.Delay->
                            sig
                              val all :
                                ('a, 'e) T2(M).t T.t -> ('T.t, 'e) T2(M).t
                              val all_ignore :
                                ('a, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val sequence :
                                (Monoid.Unit.t, 'e) T2(M).t T.t ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val map :
                                'T.t ->
                                f:('-> ('b, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val iter :
                                'T.t ->
                                f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                                (Monoid.Unit.t, 'e) T2(M).t
                              val fold :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_left :
                                'T.t ->
                                init:'->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                ('b, 'e) T2(M).t
                              val fold_right :
                                'T.t ->
                                f:('-> '-> ('b, 'e) T2(M).t) ->
                                init:'-> ('b, 'e) T2(M).t
                              val reduce :
                                'T.t ->
                                f:('-> '-> ('a, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val exists :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val for_all :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (bool, 'e) T2(M).t
                              val count :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                (Monoid.Int.t, 'e) T2(M).t
                              val map_reduce :
                                (module Monoid.S with type t = 'a) ->
                                'T.t ->
                                f:('-> ('a, 'e) T2(M).t) ->
                                ('a, 'e) T2(M).t
                              val find :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val find_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('Option.t, 'e) T2(M).t
                              val filter :
                                'T.t ->
                                f:('-> (bool, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                              val filter_map :
                                'T.t ->
                                f:('-> ('Option.t, 'e) T2(M).t) ->
                                ('T.t, 'e) T2(M).t
                            end
                      end
                    module List :
                      sig
                        val all :
                          ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t list ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t list ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'a list ->
                          f:('-> ('b, 'e) T2(M).t) -> ('b list, 'e) T2(M).t
                        val iter :
                          'a list ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'a list ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'a list ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'a list ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'a list ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'b list ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'a list ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'a list ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('a list, 'e) T2(M).t
                        val filter_map :
                          'a list ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('b list, 'e) T2(M).t
                      end
                    module Seq :
                      sig
                        val all :
                          ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                        val all_ignore :
                          ('a, 'e) T2(M).t Core_kernel.Std.Sequence.t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val sequence :
                          (Monoid.Unit.t, 'e) T2(M).t
                          Core_kernel.Std.Sequence.t ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('b, 'e) T2(M).t) ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                        val iter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (Monoid.Unit.t, 'e) T2(M).t) ->
                          (Monoid.Unit.t, 'e) T2(M).t
                        val fold :
                          'Core_kernel.Std.Sequence.t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_left :
                          'Core_kernel.Std.Sequence.t ->
                          init:'->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          ('b, 'e) T2(M).t
                        val fold_right :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> ('b, 'e) T2(M).t) ->
                          init:'-> ('b, 'e) T2(M).t
                        val reduce :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> '-> ('a, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val exists :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val for_all :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) -> (bool, 'e) T2(M).t
                        val count :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          (Monoid.Int.t, 'e) T2(M).t
                        val map_reduce :
                          (module Monoid.S with type t = 'a) ->
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('a, 'e) T2(M).t) -> ('a, 'e) T2(M).t
                        val find :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val find_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Option.t, 'e) T2(M).t
                        val filter :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> (bool, 'e) T2(M).t) ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                        val filter_map :
                          'Core_kernel.Std.Sequence.t ->
                          f:('-> ('Option.t, 'e) T2(M).t) ->
                          ('Core_kernel.Std.Sequence.t, 'e) T2(M).t
                      end
                    val ( >=> ) :
                      ('-> ('b, 'e) T2(M).t) ->
                      ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                    val ( !! ) : '-> ('a, 'e) T2(M).t
                    val ( !$ ) :
                      ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                    val ( !$$ ) :
                      ('-> '-> 'c) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                    val ( !$$$ ) :
                      ('-> '-> '-> 'd) ->
                      ('a, 'e) T2(M).t ->
                      ('b, 'e) T2(M).t ->
                      ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                    val ( !$$$$ ) :
                      ('-> '-> '-> '-> 'e) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                    val ( !$$$$$ ) :
                      ('-> '-> '-> '-> '-> 'f) ->
                      ('a, 's) T2(M).t ->
                      ('b, 's) T2(M).t ->
                      ('c, 's) T2(M).t ->
                      ('d, 's) T2(M).t ->
                      ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                    val ( >>= ) :
                      ('a, 'e) T2(M).t ->
                      ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val ( >>| ) :
                      ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) T2(M).t
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                        module Let_syntax :
                          sig
                            val return : '-> ('a, 'b) T2(M).t
                            val bind :
                              ('a, 'e) T2(M).t ->
                              f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                            val map :
                              ('a, 'e) T2(M).t ->
                              f:('-> 'b) -> ('b, 'e) T2(M).t
                            val both :
                              ('a, 'e) T2(M).t ->
                              ('b, 'e) T2(M).t -> ('a * 'b, 'e) T2(M).t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                      end
                    val bind :
                      ('a, 'e) T2(M).t ->
                      f:('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                    val return : '-> ('a, 'b) T2(M).t
                    val map :
                      ('a, 'e) T2(M).t -> f:('-> 'b) -> ('b, 'e) T2(M).t
                    val join :
                      (('a, 'e) T2(M).t, 'e) T2(M).t -> ('a, 'e) T2(M).t
                    val ignore_m :
                      ('a, 'e) T2(M).t -> (Monoid.Unit.t, 'e) T2(M).t
                    val all : ('a, 'e) T2(M).t list -> ('a list, 'e) T2(M).t
                    val all_ignore :
                      (Monoid.Unit.t, 'e) T2(M).t list ->
                      (Monoid.Unit.t, 'e) T2(M).t
                    module Syntax :
                      sig
                        val ( >>= ) :
                          ('a, 'e) T2(M).t ->
                          ('-> ('b, 'e) T2(M).t) -> ('b, 'e) T2(M).t
                        val ( >>| ) :
                          ('a, 'e) T2(M).t -> ('-> 'b) -> ('b, 'e) T2(M).t
                        val ( >=> ) :
                          ('-> ('b, 'e) T2(M).t) ->
                          ('-> ('c, 'e) T2(M).t) -> '-> ('c, 'e) T2(M).t
                        val ( !! ) : '-> ('a, 'e) T2(M).t
                        val ( !$ ) :
                          ('-> 'b) -> ('a, 'e) T2(M).t -> ('b, 'e) T2(M).t
                        val ( !$$ ) :
                          ('-> '-> 'c) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t -> ('c, 'e) T2(M).t
                        val ( !$$$ ) :
                          ('-> '-> '-> 'd) ->
                          ('a, 'e) T2(M).t ->
                          ('b, 'e) T2(M).t ->
                          ('c, 'e) T2(M).t -> ('d, 'e) T2(M).t
                        val ( !$$$$ ) :
                          ('-> '-> '-> '-> 'e) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t -> ('e, 's) T2(M).t
                        val ( !$$$$$ ) :
                          ('-> '-> '-> '-> '-> 'f) ->
                          ('a, 's) T2(M).t ->
                          ('b, 's) T2(M).t ->
                          ('c, 's) T2(M).t ->
                          ('d, 's) T2(M).t ->
                          ('e, 's) T2(M).t -> ('f, 's) T2(M).t
                      end
                    val call :
                      f:(cc:('-> ('b, 'e) T2(M).t) -> ('a, 'e) T2(M).t) ->
                      ('a, 'e) T2(M).t
                  end
            end
        end
    end
end